droide mlp - nxt software development kit - bruno matias · will allow a more liberal approach in...
TRANSCRIPT
DEPARTAMENTO DE MATEMÁTICA E ENGENHARIAS
HÉLDER GOUVEIA PESTANA
(LICENCIADO)
Tese Submetida ao Departamento de Matemática e Engenharias, Universidade da Madeira,
Portugal, como requisito parcial para a obtenção do grau de Mestre em Engenharia Informática
Orientador: Professor Doutor Eduardo Leopoldo Fermé
Funchal – Portugal
Novembro de 2008
DDRROOIIDDEE MM..LL..PP
NNXXTT SSOOFFTTWWAARREE DDEEVVEELLOOPPMMEENNTT KKIITT
ii
AGRADECIMENTOS
Em primeiro lugar, gostaria de agradecer ao Prof. Dr. Eduardo Leopoldo Fermé,
pelo apoio, entusiasmo, confiança e amizade que demonstrou ao longo do
desenvolvimento desta dissertação, pois proporcionou-me as condições
logísticas e materiais para desenvolver o trabalho aqui apresentado.
À minha namorada, Octávia Figueira, pelo carinho, apoio e compreensão ao
longo do desenvolvimento desta dissertação.
À minha família, por me ter permitido chegar até onde estou hoje.
Aos meus amigos, por me terem apoiado e me permitido atingir os objectivos
que para mim propus.
iii
A ti, por estares sempre do meu lado. Por todo o
teu amor e compreensão, agradeço-te.
iv
ABSTRACT
In our days, robotic systems are an increasing reality. People tend to use them
more and more in their everyday life, from using a washing machine, which is
already capable of determining the cloth weight and correctly distribute it, to
intelligent appliances like smart vacuum cleaners, which can vacuum a floor
without resorting to human intervention. Even though it may not seem so, such
devices are already considered small automatons, since they have sensors,
actuators and some man programmed intelligence, which allows them to take
small, but pertinent decisions. Even now, bigger and smarter systems are being
developed, and already more smart and complicated systems, that look more
alike with Man’s idea of a Robot, are being created, and robotic is becoming a
more attractive subject in education, since the youth of today will be responsible
for evolving the already existing, but very primary, robotic systems. Still, much
needs to be done in order to take the robot concept to schools and to every day
household, not as an already developed and closed system, but as a system that
helps them learn and create their own automatons. Learning kits already exist,
but they are still very limited, because they lack the proper tools to provide a
certain freedom in developing algorithmic solutions for the automatons. As so,
the main purpose of this thesis is to provide a new programming platform that
will allow a more liberal approach in programming the Lego® Mindstorms® NXT
kit, a kit that is already used as a tool in robotic education.
v
ÍNDICE
1. INTRODUÇÃO .................................................................................................................. 2
1.1. MOTIVAÇÃO E OBJECTIVOS ....................................................................................... 3
1.2. CONTRIBUIÇÕES DA DISSERTAÇÃO .............................................................................. 4
1.3. O KIT LEGO®MINDSTORMS® NXT.............................................................................. 5
1.4. ORGANIZAÇÃO DA DISSERTAÇÃO ................................................................................ 7
2. ESTADO DE ARTE ............................................................................................................. 9
2.1. PLATAFORMAS ........................................................................................................ 9
2.1.1. ROBOT C ........................................................................................................ 9
2.1.1.1. A LINGUAGEM........................................................................................... 10
2.1.1.2. A FIRMWARE ............................................................................................ 11
2.1.1.3. O EDITOR ................................................................................................. 12
2.1.2. LEGO® MINDSTORMS® NXT SOFTWARE ........................................................... 13
2.1.2.1. A LINGUAGEM........................................................................................... 14
2.1.2.2. A FIRMWARE ............................................................................................ 15
2.1.2.3. O EDITOR ................................................................................................. 16
2.1.3. LEJOS NXJ .................................................................................................... 17
2.1.3.1. A LINGUAGEM........................................................................................... 18
2.1.3.2. A FIRMWARE ............................................................................................ 19
2.1.3.3. O EDITOR ................................................................................................. 20
2.2. CONCLUSÕES ........................................................................................................ 21
3. PROJECTO DROIDE M.L.P. .............................................................................................. 24
3.1. O QUE É O DROIDE M.L.P. ...................................................................................... 24
3.2. MOTIVAÇÃO E OBJECTIVOS ..................................................................................... 28
3.3. PROJECTO DROIDE UMA ........................................................................................ 28
4. NXT SOFTWARE DEVELOPMENT KIT ................................................................................. 32
4.1. MOTIVAÇÃO E OBJECTIVOS ..................................................................................... 32
4.2. ESTRUTURA DO S.D.K. ........................................................................................... 33
4.3. FIRMWARE UTILIZADA ............................................................................................ 34
4.3.1. PBLUA.......................................................................................................... 35
4.3.2. CAMADA DE COMUNICAÇÃO ........................................................................... 36
4.3.3. INTERFACE LOADER ............................................................................................ 38
vi
4.4. BIBLIOTECAS DE COMUNICAÇÃO ............................................................................... 39
4.4.1. BIBLIOTECA JAVA ........................................................................................... 39
4.4.2. BIBLIOTECA C++ ............................................................................................ 42
4.5. BIBLIOTECAS DE CONTROLO ..................................................................................... 46
4.5.1. BIBLIOTECA JAVA ........................................................................................... 46
4.5.2. BIBLIOTECA C++ ............................................................................................ 50
4.5.3. BIBLIOTECA C# .............................................................................................. 53
4.5.4. BIBLIOTECA VB.NET ...................................................................................... 56
5. CONCLUSÃO ................................................................................................................. 61
5.1. TRABALHO DESENVOLVIDO ...................................................................................... 61
5.2. TRABALHO FUTURO................................................................................................ 61
5.3. CONCLUSÕES FINAIS ............................................................................................... 62
vii
ÍNDICE DE FIGURAS
Figura 1 – Diagrama do bloco NXT [6] ......................................................................... 7
Figura 2 – Janela principal do editor da plataforma RobotC [9] .................................. 13
Figura 3 – Janela principal da plataforma Lego® Mindstorms® NXT Software ............. 17
Figura 4 – Janela principal do I.D.E. Eclipse ............................................................... 21
Figura 5 - Framework da plataforma Droide M.L.P. ................................................... 27
Figura 6 - Estrutura do NXT S.D.K. ............................................................................. 34
Figura 7 - Excerto de código da camada de comunicação ........................................... 37
Figura 8 - Ecrã principal do Interface Loader ............................................................. 38
Figura 9 – Excerto de código da biblioteca de comunicação Java ................................ 41
Figura 10 - Diagrama de classes da biblioteca de comunicação Java ........................... 42
Figura 11 - Excerto de código da biblioteca de comunicação C++ ............................... 44
Figura 12 - Diagrama de classes da biblioteca de comunicação C++ ............................ 45
Figura 13 - Excerto de código da biblioteca de controlo Java...................................... 48
Figura 14 - Diagrama de classes da biblioteca de controlo Java .................................. 49
Figura 15 - Excerto de código da biblioteca de controlo C++ ...................................... 51
Figura 16 - Diagrama de classes da biblioteca de controlo C++ ................................... 52
Figura 17 - Excerto de código da biblioteca de controlo C# ........................................ 54
Figura 18 - Diagrama de classes da biblioteca de controlo C# ..................................... 56
Figura 19 - Excerto de código da biblioteca de controlo VbNet .................................. 58
Figura 20 - Diagrama de classes da biblioteca de controlo VbNet ............................... 59
viii
ACRÓNIMOS
S.D.K. – Software Development Kit
Kit de Desenvolvimento de Software;
V.P.L. – Virtual Programming Language
Linguagem de Programação Visual;
I.D.E. – Integrated Development Environment
Ambiente Integrado de Desenvolvimento;
M.L.P. – Multi Language Platform
Plataforma Multi Linguagens;
V.M. – Virtual Machine
Máquina Virtual;
A.P.I. – Application Package Interface
Interface de Pacote de Aplicação;
O.O.P. – Object Oriented Programming
Programação Orientada a Objectos;
1
“A robot may not injure a human being or, through inaction, allow a
human being to come to harm.”
“A robot must obey orders given to it by human beings, except where
such orders would conflict with the First Law.”
“A robot must protect its own existence as long as such protection
does not conflict with the First or Second Law.”
Three Laws of Robotics; Isaac Asimov,
2
1. INTRODUÇÃO
Actualmente, a robótica surge como uma realidade crescente, insinuando-se
cada vez mais no dia-a-dia do ser humano. Desde a realização de pequenas
tarefas, tais como a limpeza de pó, até tarefas mais complexas, tais como linhas
de montagem de automóveis ou transporte de medicamentos dentro de um
laboratório, a robótica surge com meios para providenciar respostas mais
eficientes às necessidades de empresas e de privados, providenciando soluções
que se tornam, a longo prazo, investimentos rentáveis, apesar do custo inicial da
implementação de uma destas soluções. Tal deve-se ao facto de que a robótica
actual conseguiu provar a sua eficiência e poder na realização de tarefas
repetitivas, demonstrando que um simples braço robótico consegue
desempenhar certas tarefas melhor que seres humanos. Trabalhos que
necessitem de velocidade, precisão, confiança e resistência podem ser realizados
muito mais eficientemente por robots do que por seres humanos [1]. No
entanto, a robótica é uma área em crescente evolução e os seus investigadores
procuram novas soluções, quer a nível electrónico, quer a nível de programação,
que permitam a criação de máquinas cada vez mais autónomas, capazes de
tomar decisões de acordo com o ambiente circundante. Actualmente, já é
possível criar máquinas com características autónomas, capazes de reagir
adequadamente em ambientes controlados, tais como robots de limpeza ou
robots utilizados para cortar a relva [1]. No entanto, máquinas mais eficientes
ainda estão a ser alvo de investigação, tais como os nano robots ou robots
evolucionários.
Hoje existe uma motivação cada vez maior para o ensino de robótica nas escolas,
especialmente no ensino secundário. O ensino de robótica nas universidades é
uma realidade que já existe há alguns anos, mas o nível de complexidade dos
autómatos, bem como o nível de educação e compreensão necessários para a
montagem e programação dos mesmos, levaram a que se tornasse complicado
partilhar este conhecimento com os mais jovens, pelo menos de uma forma mais
3
prática. No entanto, cada vez mais surgem Kits educativos, tais como o Kit Lego
Mindstorms NXT, que são virados para o ensino de robótica no secundário,
especialmente para jovens com idades entre os 8 e 14 anos. Os objectivos
pretendidos com estes kits são os de levar estes jovens desenvolver capacidades
tais como a análise de requisitos e ambiente, a aprendizagem de princípios de
desenho na construção de autómatos, o desenvolvimento de competências na
área de programação e uma maior dinâmica de grupo [2]. Estes kits têm a
enorme vantagem de facilitar a tarefa de montagem e prototipagem dos robots,
pois não requerem conhecimentos em electrónica, visto que foram criados com
o intuito de facilitar a sua utilização em ambientes escolares mais jovens, bem
como para atrair leigos na matéria. Tal leva a que seja necessário a existência de
cada vez mais e melhores ambientes de programação, que permitam aos alunos
ou interessados aplicar e desenvolver soluções algorítmicas nas linguagens de
programação que pretendam, de uma forma fácil e prática, garantindo cada vez
mais uma maior liberdade e eficiência no desenho, concepção, montagem e
programação destes kits.
1.1. MOTIVAÇÃO E OBJECTIVOS
Neste trabalho de investigação, a principal motivação foi desenvolver uma
plataforma que facilitasse a programação do Kit Lego® Mindstorms® NXT em
diferentes linguagens, sem no entanto recorrer a uma interface gráfica para o
efeito. Actualmente, existem variadas plataformas para a programação destes
kits, desde plataformas que recorrem a blocos de código e interfaces gráficas a
plataformas programáveis, que exigem que o utilizador saiba necessariamente
programar numa linguagem específica. Ambos os tipos de plataformas têm as
suas vantagens e desvantagens, entre as quais podemos indicar a facilidade de
programação, quando recorremos a plataformas gráficas, ou maior liberdade de
expressão a nível de algoritmia, quando recorremos a plataformas programáveis.
No entanto, todas estas plataformas estão limitadas a uma só linguagem de
programação, levando a que o utilizador necessite de efectuar diversas pesquisas
4
quando pretende mudar a forma de programar o seu kit. Adicionalmente, muitas
das plataformas que encontramos ainda apresentam obstáculos na sua
configuração e utilização, quer por dificuldades técnicas, quer por má
documentação. Outra das dificuldades centra-se ainda no facto de certas
linguagens de programação ainda não se encontram disponíveis para programar
o Kit Lego® Mindstorms® NXT, levando a que o utilizador fique limitado às
linguagens existentes. Como tal, os objectivos principais deste trabalho de
investigação são:
• Desenvolver uma plataforma programável para a utilização com o Kit
Lego® Mindstorms® NXT;
• Possibilitar a programação do Kit Lego® Mindstorms® NXT em 4
diferentes linguagens de programação
• Facilitar a mudança entre diferentes linguagens de programação,
minimizando o esforço de aprendizagem da plataforma ao recorrer a uma
nova linguagem;
• Criar material de suporte para a instalação, configuração e utilização da
plataforma desenvolvida
1.2. CONTRIBUIÇÕES DA DISSERTAÇÃO
Com vista a contemplar os objectivos aqui propostos, esta dissertação apresenta
os seguintes contributos:
• Realização de um estudo do estado de arte sobre algumas das diferentes
plataformas utilizadas actualmente na programação do Kit Lego®
Mindstorms® NXT. Neste será abordado quais as linguagens disponíveis
para a programação do Kit em cada plataforma, qual a firmware utilizada,
qual o editor disponível para a programação, quais as vantagens e
desvantagens de cada uma, inclusive no que toca à facilidade de
configuração e utilização, e, finalmente, quais as limitações ainda
encontradas nas ferramentas disponíveis para o Kit.
5
• Explicação sobre o projecto Droide M.L.P., relativamente à sua motivação
e objectivos, ao seu enquadramento com o projecto Droide UMa e à sua
utilização como ferramenta de ensino.
• Construção de um S.D.K. central para a plataforma Droide M.L.P.,
designado por NXT S.D.K., que irá ser utilizado para a programação do Kit
Lego® Mindstorms® NXT. Este, por sua vez, irá conter o suporte para as
linguagens de programação Java, C++, C# e Vb.Net, através de um
conjunto de bibliotecas para o efeito.
• Criação de um conjunto de material de suporte para a instalação,
configuração e utilização do NXT S.D.K. que será utilizado, por sua vez,
para facilitar a utilização da plataforma Droide M.L.P.
1.3. O KIT LEGO®MINDSTORMS® NXT
A área de robótica exige um conhecimento prático de electrónica, mecânica e
software, além de que muitas vezes é necessário possuir conhecimentos
adicionais noutras áreas [3]. Adicionalmente, os custos envolvidos na concepção
e montagem de um autómato, quer a nível de tempo, quer a nível monetário,
são elevados, o que restringe o seu acesso a somente alguns grupos de pessoas
ou empresas. No entanto, esforços já existem com vista a tornar esta área cada
vez mais acessível a qualquer pessoa, especialmente no que toca à educação,
visto que a robótica é vista como uma área promissora no ensino. Os robots
móveis transformam a computação etérea numa realidade palpável, e, como
resultado, eles têm o potencial para excitar e inspirar crianças e adultos de uma
forma que nenhum computador consegue. Os robots em si representam um
sistema híbrido - dinâmico inerentemente fascinante para estudo e
compreensão [4]. Como tal, kits como o Kit Lego® Mindstorms® NXT surgem para
preencher a lacuna existente entre os robots de alto nível e de mais difícil
compreensão e os utilizadores iniciantes, que procuram se insinuar na área da
robótica sem, no entanto, necessitarem de efectuar grandes estudos na mesma.
Isto vem a facilitar a tarefa do utilizador, bem como aumentar o número de
6
interessados na área, pois torna-se cada vez mais acessível comprar e trabalhar
com um destes kits.
O Kit Lego® Mindstorms® NXT é um kit robótico programável que começou a ser
comercializado pela Lego® em finais de Julho de 2006. Ele veio substituir o Kit
Lego® Mindstorms® da primeira geração, que era denominado de Robotics
Invention System. O kit base é vendido em duas versões: A Retail Version e o
Education Base Set [5]. Este Kit, por sua vez, é composto por diversas
componentes, entre as quais podemos encontrar um pequeno computador em
forma de bloco, denominado de bloco NXT, motores, sensores e cabos. O
principal componente do kit é, sem dúvida, o bloco NXT. Este aceita como
entrada um máximo de quatro sensores e consegue controlar até três motores,
tudo através de cabos RJ12, muito similares, mas incompatíveis, com os cabos de
telefone RJ11. O bloco tem um ecrã monocromático LCD de 100x64 pixéis e
quatro botões […]. Possui também uma coluna e consegue tocar ficheiros de som
até uma escala de 8KHz. A energia é fornecida por 6 baterias AA (1.5 V cada) […]
e por uma bateria recarregável de Li-Ion e o respectivo carregador […]. Possui
também um processador interno Atmel® ARM7, com 256 Kb de memória flash e
64Kb de memória RAM [5]. Podemos ver um esquema do bloco na Figura 1.
A escolha deste Kit como ferramenta de trabalho para esta dissertação teve,
como um dos motivos principais, o facto de este ser virado para o ensino da
robótica em geral, sendo, como tal, um kit fácil de trabalhar. Isto prova ser
vantajoso, pois vem facilitar a tarefa de montagem e prototipagem do robot,
permitindo o seu uso em ambientes escolares mais jovens, bem como por leigos
na matéria, e levando a uma maior dedicação e foco na componente de
programação e algoritmia.
7
Figura 1 – Diagrama do bloco NXT [6]
1.4. ORGANIZAÇÃO DA DISSERTAÇÃO
Esta dissertação encontra-se organizada em cinco capítulos.
O capítulo 1 “Introdução”: Apresenta as motivações e objectivos desta
dissertação, contributos e uma breve descrição do Kit Lego® Mindstorms® NXT.
Por fim, um resumo da organização da dissertação;
O capítulo 2 “Estado de Arte”: Apresenta o estado de arte de três plataformas de
programação para o Kit Lego® Mindstorms® NXT. Neste capítulo são
especificados alguns detalhes e limitações de cada uma das plataformas
mencionadas.
O capítulo 3 “Projecto Droide M.L.P.”: Apresenta a plataforma Droide M.L.P.,
descrevendo as motivações e objectivos e a sua integração com o projecto
Droide UMa;
O capítulo 4 ”NXT Software Development Kit”: Apresenta a contribuição desta
dissertação;
O capítulo 5 ”Conclusão”: Apresenta o trabalho desenvolvido ao longo desta
dissertação bem como algumas propostas de trabalhos futuros que serão
desenvolvidos. Para finalizar, são feitas as conclusões finais.
8
"We are shaping the world faster than we can change ourselves, and
we are applying to the present, the habits of the past.”
Sir Winston Churchill
9
2. ESTADO DE ARTE
Existem diferentes plataformas de programação disponíveis no mercado para a
utilização com o Kit Lego® Mindstorms® NXT, umas pagas e outras gratuitas.
Entre elas, podemos encontrar plataformas mais adequadas para utilizadores
iniciantes, que tiveram pouco ou nenhum contacto com linguagens de
programação, e plataformas mais adequadas a utilizadores com experiência em
linguagens de programação, que permitem uma programação mais directa do Kit
Lego® Mindstorms® NXT, embora estes últimos estejam limitados às linguagens
fornecidas com cada plataforma, o que em si pode se tornar uma limitação, se o
utilizador não tiver conhecimento das linguagens em questão. O objectivo da
secção 2.1 será abordar algumas das plataformas mais conhecidas para o Kit
Lego® Mindstorms® NXT, tentando especificar os detalhes de cada uma. Na
secção 2.2, serão discutidas algumas das limitações encontradas, no geral, para
as plataformas abordadas.
2.1. PLATAFORMAS
Como já mencionado anteriormente, existem diferentes plataformas de
programação disponíveis para o Kit Lego® Mindstorms® NXT. Assim sendo, será
feito aqui um estudo de algumas destas, numa tentativa de demonstrar as suas
características e vantagens.
2.1.1. ROBOT C
Uma das plataformas mais potentes que é possível encontrar para a
programação do Kit Lego® Mindstorms® NXT é a plataforma RobotC. Apesar de
se tratar de uma plataforma paga, esta possui inúmeras vantagens, tais como o
seu próprio editor e um conjunto de tutoriais para a programação do kit em
questão, e é ideal para programadores principiantes e avançados […]. Ela
possibilita o ensino de Programação Avançada, Engenharia, Mecatrónica e
Sistemas Embebidos [7]. Para o efeito, esta baseia-se na linguagem C e utiliza um
10
ambiente em Windows para a escrita e depuração de programas, sendo que é a
única linguagem a este nível que oferece um depurador compreensivo e em
tempo real.
A plataforma RobotC foi desenvolvida pela reconhecida equipa de Educação
Robótica, pertencente à Academia de Robótica da Universidade de Carnegie
Mellon [8] e encontra-se disponível com licenciamentos e pacotes próprios,
concebidos para a utilização em salas de aula ou uso particular.
2.1.1.1. A LINGUAGEM
A linguagem suportada pela plataforma RobotC é a linguagem C standard, que já
vem há muito a ser utilizada no desenvolvimento das mais variadas aplicações e
sistemas operativos. Por se tratar de uma linguagem poderosa e muito bem
documentada, visto a sua longa história, esta vem a se provar ser uma boa
escolha para o tipo de plataforma pretendida, pois irá fornecer um suporte
adequado a programadores mais experientes que pretendam desenvolver uma
aplicação mais robusta e complexa. No entanto, esta não exclui os
programadores menos experientes, pois a sua sintaxe encontra-se bem
documentada, quer em livros, quer em websites desenvolvidos para o efeito.
Adicionalmente, o RobotC foi desenvolvido para dotar os programadores menos
experientes de conceitos que podem ser transferidos para outras linguagens de
programação [8].
O suporte para a programação do Kit Lego® Mindstorms® NXT é feito através da
adição de novas extensões à linguagem C, extensões essas que irão ser utilizadas
na comunicação e desenvolvimento de código para o kit em questão, bem como
para outros dois kits suportados pela plataforma, o VEX e o Kit Lego Mindstorms
RCX. Adicionalmente, existem funcionalidades adicionais na plataforma que não
são regularmente encontradas noutras plataformas robóticas, tais como o
suporte a matemática de vírgula flutuante, funções trigonométricas e
capacidades de multi-tarefas [8].
11
De notar que o RobotC é considerada uma plataforma de controlo remoto [9], ou
seja, é necessário manter uma comunicação constante entre o bloco robótico
(no caso do Kit Lego® Mindstorms® NXT é o bloco NXT) e a plataforma para que o
código escrito seja executado, sendo que esta comunicação é garantida
normalmente através do cabo USB ou da ligação Bluetooth [9].
2.1.1.2. A FIRMWARE
A plataforma RobotC inclui uma firmware própria para utilização com o Kit Lego®
Mindstorms® NXT. Esta foi desenvolvida com o propósito de maximizar o
desempenho do Kit em questão, através da adição de novas funcionalidades e
características que não são encontradas noutras plataformas robóticas. Tais
incluem um tempo de execução 10 a 100 vezes superiores a outras soluções
actuais para o Kit Lego® Mindstorms® NXT, leitura de sensores executada por
tarefas em segundo plano, funções expandidas para o ecrã LCD, maior potência
de saída no canal de comunicação Bluetooth, suporte a multitarefas com
atribuição de prioridades, que irá possibilitar a criação de um código mais
eficiente, e pequenas funções utilitárias que incluem, por exemplo, aviso de
bateria fraca [8].
Tal investimento no desenvolvimento de uma firmware mais eficiente é
compensador, visto que a plataforma RobotC é considerada como uma das
plataformas mais rápidas a nível de execução de código, como pode ser visto na
tabela comparativa apresentada em [9].
Uma curiosidade que merece ser mencionada é facto de a plataforma RobotC se
desviar da linguagem C tradicional ao implementar uma V.M. Esta torna a
plataforma RobotC numa cross-plataform, ao fornecer o suporte para três kits
diferentes, em que cada um destes irá ter uma firmware própria e a respectiva
tradução das instruções V.M. para a linguagem específica do bloco [10] [11].
Como tal, o programador poderá transportar o seu código de um kit para outro
sem ter que se preocupar em fazer grandes ajustes no seu código, embora possa
12
ser necessário efectuar pequenas alterações no seu código. Assim sendo, a V.M.
irá funcionar como interface entre o código desenvolvido pelo utilizador e o kit
utilizado pelo mesmo, em que as instruções programadas pelo utilizador serão
convertidas em instruções da V.M., através de um interpretador próprio da
plataforma [11], que, por sua vez, serão interpretadas de acordo com a firmware
e kit utilizado, minimizando erros inerentes à má gestão de memória, entre
outros.
2.1.1.3. O EDITOR
Um dos pontos fortes da plataforma RobotC é o editor disponibilizado na
plataforma. Tal deve-se ao facto de este ser um editor de código desenvolvido a
pensar na linguagem C, e não um simples editor de texto. Como tal, possui
características tais como indentação automática, de acordo com a estrutura e
sintaxe do código, um editor de texto preditivo, sugestões que surgem ao
seleccionar uma keyword, completação de código, o único depurador interactivo
disponível para o Kit Lego® Mindstorms® NXT, e código colorido, para facilitar a
identificação de variáveis e keywords no código [8]. Além destas características
base, o editor possui também um compilador / downloader integrado, que
permite o upload e teste directo do código com o Kit Lego® Mindstorms® NXT,
sem que para tal seja necessário utilizar programas secundários para o efeito.
Um dos pontos mais fortes do editor é, sem dúvida, os templates de código
fornecidos, que podemos encontrar no lado direito da janela do mesmo, tal
como mostra a Figura 2. Estes templates de código facilitam a tarefa do
utilizador, que pode recorrer aos mesmos para programar com mais facilidade,
bem como para se ambientar à sintaxe e funções fornecidas pela plataforma
para a programação do Kit Lego® Mindstorms® NXT, minimizando os erros que
surgem da falta de conhecimento das funções e da sintaxe da plataforma ou da
linguagem utilizada. Adicionalmente, é possível optar entre um modo básico e
um modo avançado, de acordo com o tipo de utilizador, sendo que o modo
básico é mais adequado a programadores iniciantes e o avançado a
13
programadores experientes, que necessitam de funções mais avançadas. Estes
modos ocultam ou disponibilizam templates de código mais avançados para a
programação do Kit Lego® Mindstorms® NXT [8].
Figura 2 – Janela principal do editor da plataforma RobotC [10]
2.1.2. LEGO® MINDSTORMS® NXT SOFTWARE
Uma das plataformas disponíveis para a programação do Kit Lego® Mindstorms®
NXT é a plataforma fornecida de origem com o mesmo e com o nome de Lego®
Mindstorms® NXT Software. Desenvolvida a pensar na educação e com o intuito
de atrair crianças e iniciantes na área da robótica sem, no entanto, descurar
programadores mais avançados, esta plataforma permite a programação dos
robots NXT e o upload dos programas criados para o bloco NXT através de cabo
USB ou por Bluetooth. O editor, baseado na plataforma LabVIEW, da National
Instruments, vem com um conjunto de instruções e guias de programação para
auxiliar na construção e programação do Kit Lego® Mindstorms® NXT de uma
forma fácil e prática [12] [13].
14
O objectivo foi desenvolver uma plataforma que tornasse a programação do Kit
Lego® Mindstorms® NXT intuitiva e entretida e tal foi obtido recorrendo a uma
parceria com a National Instruments, empresa de renome que lançou o seu
produto revolucionário em 1986, o LabVIEW, utilizado actualmente como
ferramenta empresarial por muitos cientistas e engenheiros que pretendam
desenvolver rapidamente aplicações sem que para tal tenham que adquirir
conhecimentos extensos em programação [12].
Esta ferramenta, baseada em ícones e software drag-and-drop, é intuitiva para
todos, quer sejam crianças ou programadores profissionais, e leva a que seja
possível programar invenções robóticas com os mais diversos objectivos de uma
forma rápida [12].
2.1.2.1. A LINGUAGEM
A linguagem utilizada pela plataforma Lego® Mindstorms® NXT Software é a
NXT-G, que é considerada uma linguagem de programação visual ou V.P.L. [5]
Uma V.P.L. é uma linguagem de programação que permite aos seus utilizadores a
criação de programas através da manipulação de elementos de programação
gráficos, em vez da tradicional escrita de linhas de código. Esta permite a
utilização de expressões visuais para programação, a organização visual de
código e a utilização de símbolos gráficos como representação de métodos ou
funções. A maior parte das V.P.L.’s são baseadas no conceito de “setas e caixas”,
em que os elementos de programação são caixas ou círculos conectados através
de linhas, arcos ou setas. Adicionalmente, estas linguagens podem ser
classificadas, de acordo com o tipo, intenção e extensão da linguagem utilizada,
como linguagens baseadas em ícones ou linguagens diagramáticas, entre outras
[14].
Regra geral, os ambientes de programação para linguagens V.P.L. providenciam
ao utilizador ferramentas para manipulação dos elementos gráficos de uma
15
forma estruturada e organizada, de acordo com uma gramática espacial
específica para a construção do programa.
No caso da linguagem NXT-G, esta é considerada o núcleo da plataforma Lego®
Mindstorms® NXT Software, tornando a construção de programas complexos
fácil e rápida, simplesmente utilizando pequenos blocos de código que são
depois combinados para construir programas mais complexos. Cada programa é
depois carregado no bloco NXT e torna-se acessível através do menu principal do
bloco. No entanto, existe uma limitação derivada do facto de que este género de
programas rapidamente preenche a limitada memória do bloco, levando a que
programas muito extensos não possam ser utilizados [15].
Como tal, esta linguagem é aconselhável para programação básica do Kit Lego®
Mindstorms® NXT, tal como movimento básico, utilização de estruturas básicas
de comando, utilização de funcionalidades básicas dos sensores, entre outras.
Para programas mais complexos, é recomendado o uso de linguagens de
programação mais potentes, visto que a NXT-G apresenta algumas limitações a
nível do controlo de sensores e de movimentos, bem como apresenta erros
aquando na criação de programas mais complexos, levando a bloqueios do bloco
e à perca de informação [5].
2.1.2.2. A FIRMWARE
A plataforma Lego® Mindstorms® NXT Software utiliza uma firmware
desenvolvida pela Lego®. Inicialmente uma firmware de código fechado, a Lego®
decidiu libertar a sua firmware como código aberto com vista a permitir a sua
utilização na criação de plataformas por terceiros, bem como possibilitar o
melhoramento da firmware em si, quer pela adição de novas funcionalidades,
quer pela modificação de funcionalidades já existentes. Adicionalmente,
encontram-se disponíveis S.D.K.’s para utilização no desenvolvimento de novas
plataformas para o Kit Lego® Mindstorms® NXT, bem como para permitir o
desenvolvimento de novos sensores para o mesmo kit [13] [5].
16
A firmware em si instala um pequeno S.O. no bloco NXT, através da qual é
possível executar código já carregado para o bloco. Adicionalmente, permite
efectuar diversos testes aos sensores e motores ligados ao bloco NXT, bem como
correr pequenos exemplos para melhor compreender a funcionalidade de cada
motor e sensor. Trata-se de uma firmware intuitiva e simples de trabalhar, o que
auxilia na utilização do Kit Lego® Mindstorms® NXT como ferramenta educativa.
2.1.2.3. O EDITOR
A plataforma Lego® Mindstorms® NXT Software vem com um editor integrado
para a programação do Kit Lego® Mindstorms® NXT. Recorrendo à V.P.L. NXT-G,
a plataforma integra um ambiente gráfico de desenvolvimento, que foi criado
graças a uma parceria entre a Lego e a National Instruments, sendo que a última
baseou-se na sua própria plataforma de programação, a plataforma LabVIEW,
para desenvolver a plataforma que hoje é fornecida no Kit Lego® Mindstorms®
NXT [12]. Esta plataforma representa uma ferramenta fácil de utilizar para o
utilizador iniciante, visto que não são necessários conhecimentos alguns de
programação para começar a programar no Kit Lego® Mindstorms® NXT. Basta
clicar sobre blocos de código, que foram criados especificamente para o efeito, e
arrastá-los para o ambiente principal da plataforma. Estes são automaticamente
ligados aos blocos anteriores ou ao bloco inicial, que já se encontra inserido no
ambiente logo no inicio. Adicionalmente, a plataforma possui um software
integrado, denominado de RoboLab™, que permite ao utilizador iniciante seguir
um conjunto de desafios e tutoriais para a criação do seu primeiro robot [16].
Tal leva a que esta plataforma esteja perfeitamente enquadrada no ambiente do
ensino, pois contém ferramentas particularmente úteis para o utilizador
iniciante. A sua limitação encontra-se somente quando é necessário desenvolver
programas mais complexos, visto ser algo limitada no que toca ao
desenvolvimento de algoritmos e programação avançada. A Figura 3 mostra-nos
um exemplo do editor da plataforma.
17
Figura 3 – Janela principal do editor da plataforma Lego® Mindstorms® NXT Software
2.1.3. LEJOS NXJ
A plataforma Lejos consiste num conjunto de uma firmware (de mesmo nome
que a plataforma) e uma A.P.I. Java para a programação dos Kits Lego®
Mindstorms®, sendo que existem versões separadas para cada um dos kits em
questão, o Kit Lego® Mindstorms® RCX e o Kit Lego® Mindstorms® NXT. Esta
plataforma é utilizada, muitas vezes, para o ensino da linguagem Java aos alunos
de primeiro ano de cursos informáticos [17]. Trata-se de uma das poucas
plataformas disponíveis para a programação do Kit Lego® Mindstorms® NXT na
linguagem Java, sendo a primeira aqui abordada que suporta o paradigma O.O.P.
Nesta dissertação, será abordada a plataforma Lejos NXJ, que é a versão da
plataforma Lejos para o Kit Lego® Mindstorms® NXT. Esta versão suporta a
linguagem Java, permite a utilização de threads, suporta excepções, e inclui os
tipos básicos do java, entre outras [18].
18
2.1.3.1. A LINGUAGEM
A linguagem utilizada por esta plataforma é a linguagem de programação Java.
Esta linguagem foi originalmente desenvolvida pela Sun® Microsystems® e surgiu
pela primeira vez em 1995 como um componente chave da plataforma Java da
Sun® Microsystems®. A linguagem deriva muita da sua sintaxe das linguagens de
programação C e C++, mas possui um modelo de objectos mais simples, bem
como um menor acesso a funcionalidades de baixo nível. Por norma, as
aplicações desenvolvidas em Java são compiladas para bytecode e necessitam de
uma V.M. para poderem executar, independentemente da arquitectura da
máquina ou do sistema operativo utilizado para o efeito. Isto leva a que esta
linguagem seja considerada independente da plataforma, o que significa que os
programas escritos nesta devem correr de forma semelhante em qualquer
conjunto máquina / sistema operativo suportados. Isto deve-se ao facto de o
compilador desta linguagem compilar o código num formato específico (Java
bytecode), recorrendo depois a uma chamada V.M. para executar o bytecode,
em que esta máquina virtual irá ser responsável por interpretar o código para a
arquitectura de hardware e software subjacentes à máquina onde o programa
Java encontra-se a ser executado [19].
Uma das principais vantagens desta linguagem é o facto de esta possuir uma
gestão de memória automática, o chamado Garbage Collector, em que o
programador é aliviado da tarefa de gestão de memória, tendo somente que se
preocupar com a criação de objectos. O tempo de vida do objecto ficará a cargo
do ambiente de execução do Java, sendo que este irá eliminar objectos que já
não se encontrem em uso [19].
Outra das vantagens que podemos encontrar na linguagem é o facto de
existirem já um conjunto enorme de módulos e extensões para a linguagem.
Desde que saiu para o mercado como uma linguagem opensource, inúmeras
extensões, módulos e inclusive editores gratuitos foram também criados,
levando a que o utilizador que pretenda usufruir por completo das
19
potencialidades desta linguagem possa recorrer a inúmeros recursos gratuitos
disponibilizados online.
No entanto, como ponto negativo, temos o desempenho da linguagem. Embora
tenha aumentado substancialmente desde o seu início, continua a ser um factor
crítico para a escolha da linguagem, pois esta apresenta ainda um menor
desempenho que outras linguagens como o C++ [19]. Adicionalmente, aplicações
muito extensas desenvolvidas na linguagem Java necessitam de máquinas
potentes, de preferência com grandes quantidades de memória RAM, sob
penalização de um menor desempenho no geral do programa desenvolvido.
O Lejos NXJ possui uma API bem documentada para a utilização com a linguagem
Java, com vista a programar o Kit Lego® Mindstorms® NXT [18]. Para um
utilizador com alguma experiência em linguagens que suportem o paradigma
O.O.P. e que pretenda criar um programa mais complexo para o Kit Lego®
Mindstorms® NXT, o Lejos NXJ apresenta uma boa solução para programar o
mesmo, pois a linguagem Java trata-se de uma linguagem potente, bem como
possui imensos recursos gratuitos online, como já mencionado anteriormente.
2.1.3.2. A FIRMWARE
A plataforma Lejos NXJ possui uma firmware própria para a programação Kit
Lego® Mindstorms® NXT. Desenvolvida de raiz e sem recorrer à firmware
opensource disponibilizada pela Lego® para o Kit Lego® Mindstorms® NXT, esta
possui imensos recursos tais como comunicação por Bluetooth, suporte a
sensores I2C, sistema de ficheiros, eventos concorrentes, matemática de virgula
flutuante, entre outros. Trata-se de uma das firmwares gratuitas e desenvolvidas
de raiz mais potentes disponíveis, sendo este um dos pontos fortes da
plataforma [18].
Como tal, esta plataforma é ideal para quem procura desenvolver aplicações
mais complexas para o Kit Lego® Mindstorms® NXT, sendo que o número de
funcionalidades disponibilizadas pela firmware leve a que a mesma seja mais
20
potente que a firmware original disponibilizada no kit, bem como a linguagem
suportada permite uma maior liberdade de implementação e desenvolvimento
de aplicações.
2.1.3.3. O EDITOR
A plataforma Lejos NXJ não possui um editor incluído na plataforma. No entanto,
no site oficial da plataforma, que é possível encontrar em [18], é aconselhável a
utilização do I.D.E. gratuito Eclipse, que é considerado um dos melhores editores
opensource disponíveis.
O Eclipse é um ambiente de desenvolvimento integrado e é desenvolvido
primariamente em Java. Trata-se de um I.D.E., na sua forma básica,
essencialmente orientado para programadores de Java sendo que, no entanto,
os seus utilizadores podem expandir as suas capacidades através da adição de
novos plugins, escritos para a Framework de software do Eclipse, e que
adicionam novas características e funcionalidades, tais como kits de
desenvolvimento para outras linguagens de programação. O Eclipse é um
projecto opensource em constante desenvolvimento pela comunidade
opensource. O objectivo principal é desenvolver um I.D.E. extensível, que
possibilite o desenvolvimento e gestão de projectos de software ao longo do
ciclo de vida destes [20] [21].
Uma das desvantagens, no entanto, que é possível encontrar na utilização do
Eclipse com a plataforma Lejos NXJ é a dificuldade existente na configuração e
utilização do I.D.E. É um I.D.E. avançado e algo complexo, que não é aconselhado
para utilizadores novatos, visto que a sua interface, apesar de apelativa e
completa, não é intuitiva para utilizadores que nunca tenham tido contacto com
um I.D.E. do género. Adicionalmente, o site oficial da plataforma Lejos NXJ não
oferece um tutorial adequado para a instalação do Eclipse e para a sua
configuração e utilização com a plataforma em questão.
21
Figura 4 – Janela principal do I.D.E. Eclipse
2.2. CONCLUSÕES
Através do estudo destas três plataformas, é possível verificar que algumas das
plataformas disponíveis para a programação do Kit Lego® Mindstorms® NXT
representam ferramentas potentes e adequadas aos vários níveis de
aprendizagem pretendidos para os diferentes utilizadores, quer eles sejam
utilizadores inexperientes, em que seria recomendada a utilização da plataforma
Lego® Mindstorms® NXT Software, utilizadores com alguma experiência, em que
seria recomendada a utilização da plataforma RobotC, ou utilizadores
experientes em que seria recomendada a utilização das plataformas RobotC ou
Lejos NXJ. No entanto, surgem ainda algumas limitações no que toca à utilização
destas plataformas. Por exemplo, no caso da plataforma RobotC, trata-se de uma
potente plataforma, mas que possui uma licença que terá que ser adquirida caso
a sua utilização seja necessária por mais do que 30 dias. Para um utilizador que
faça da robótica o seu passatempo, isso não representa um grave problema, mas
para o caso de um estabelecimento de ensino, surge a necessidade de compra de
inúmeras licenças, o que se torna já algo dispendioso. Outra sugestão seria
recorrer à plataforma fornecida com o Kit Lego® Mindstorms® NXT, a plataforma
Lego® Mindstorms® NXT Software. Só que, no caso de uma instituição de ensino
22
de nível mais avançado, que pretenda introduzir conceitos mais interessante na
área de inteligência artificial, surge o problema da linguagem utilizada ou, mais
concretamente, da sua limitação a nível de expressividade pois, tratando-se de
uma V.P.L., impede que certos conceitos mais avançados sejam implementados.
Finalmente, poderia ser considerada a plataforma opensource Lejos NXJ, que se
trata de uma excelente plataforma para a programação mais avançada do Kit
Lego® Mindstorms® NXT. No entanto, a falta de tutoriais adequados leva a que a
tarefa de utilização desta plataforma tenha dificuldades acrescidas no que toca à
compreensão e configuração da mesma.
23
“Therefore we have to go over the fact that all human beings are afraid
by what is new. It is our work to convince them that they will enjoy
it[...]”
Christo
24
3. PROJECTO DROIDE M.L.P.
Como mencionado no capítulo anterior, existem cada vez mais plataformas
disponíveis para a programação do Kit Lego® Mindstorms® NXT. Algumas destas
são excelentes plataformas, com características adequadas a quaisquer
utilizadores, quer utilizadores iniciantes, quer utilizadores de nível mais
avançado, e apresentam excelentes recursos para educação. Outras, no entanto,
apesar de apresentarem excelentes recursos a nível de programação,
encontram-se limitadas ou a nível da linguagem, ou a nível de material para
apoiar a sua utilização na programação do Kit Lego® Mindstorms® NXT, devido à
complexidade da sua preparação e configuração. Adicionalmente, algumas
destas plataformas estão sujeitas a licenciamento, o que pode invalidar a sua
escolha devido à falta de recursos financeiros, especialmente se estas se
inserirem no ambiente educacional, onde existe a necessidade de obter diversas
licenças.
Neste contexto, e com o objectivo de fornecer uma plataforma que tente
colmatar algumas destas lacunas, surge o projecto Droide M.L.P., que pretende
ser uma plataforma para auxiliar o desenvolvimento de aplicações para o Kit
Lego® Mindstorms® NXT em diferentes linguagens de programação,
encontrando-se munida de um conjunto de guias e tutoriais para auxiliar na sua
configuração e utilização.
3.1. O QUE É O DROIDE M.L.P.
O projecto Droide M.L.P. surge como uma plataforma para a programação do Kit
Lego® Mindstorms® NXT e é fruto do esforço colaborativo de dois alunos, que se
encontram actualmente a concluir o Mestrado em Engenharia Informática pela
Universidade da Madeira. Esta permite a programação do referido Kit em 6
linguagens de programação distintas (C++, C#, VB, Java, Prolog, Pascal), em que
quatro destas suportam o paradigma O.O.P. Adicionalmente, esta plataforma
ainda vem munida com um conjunto de I.D.E.’s adequados a cada linguagem de
25
programação, todos eles considerados freeware ou opensource, bem com um
conjunto de tutoriais e guias de instalação, com vista a facilitar a sua utilização
por parte do utilizador final.
O núcleo central da plataforma é denominado de NXT Software Development Kit,
adiante referido como NXT S.D.K., e consiste num conjunto de bibliotecas criadas
para suportar a programação do Kit Lego® Mindstorms® NXT nas quatro
linguagens que suportam o paradigma O.O.P., que são as linguagens C++, C#,
VB.Net e Java. As duas linguagens adicionais, a linguagem Pascal e a linguagem
Prolog, encontram-se disponíveis como dois módulos adicionais para o núcleo da
plataforma, e devem ser instalados separadamente. A relação existente entre os
diferentes módulos pode ser vista na Figura 5.
Relativamente aos I.D.E.’s fornecidos, estes podem ser descarregados
gratuitamente da Web. No entanto, o objectivo desta plataforma é facilitar a sua
utilização e instalação em qualquer ambiente, logo também estes se encontram
disponíveis como parte da plataforma com vista a facilitar a sua instalação sem
que para tal seja necessário descarregar os mesmos da Web, embora o utilizador
seja livre de o fazer.
Finalmente, como já mencionado anteriormente, a plataforma possui um
conjunto de manuais de instalação e documentação das bibliotecas
disponibilizadas para programação do Kit, bem como um conjunto de actividades
desenvolvidas especificamente para proporcionar uma melhor aprendizagem da
plataforma e das suas potencialidades. Toda esta documentação pode ser
acedida directamente no CD2 da plataforma Droide M.L.P.
Como podemos ver na Figura 5, a plataforma encontra-se estruturada em
diversas bibliotecas, todas estas especificamente concebidas para possibilitar a
programação do Kit Lego® Mindstorms® NXT nas diferentes linguagens
propostas. No entanto, parte desta estrutura (marcada a laranja na Figura 5) é
parte integrante do NXT S.D.K. e será apresentada como contribuição desta
dissertação. A restante estrutura (marcada a cinzento na Figura 5) será
26
apresentada como parte da tese de mestrado da aluna Octávia Raquel Gomes
Figueira, com o título “Droide M.L.P. - Potencializando a Plataforma”.
Adicionalmente, serão disponibilizados, como anexo desta dissertação, os
manuais necessários para a instalação e configuração do NXT S.D.K., bem como
para a configuração dos I.D.E.’s recomendados para cada uma das 4 linguagens
aqui mencionadas.
27
Figura 5 - Framework da plataforma Droide M.L.P.
28
3.2. MOTIVAÇÃO E OBJECTIVOS
Como mencionado no capítulo 2 desta dissertação, actualmente muitas
plataformas disponíveis para o Kit Lego® Mindstorms® NXT, apesar das suas
capacidades e diversas funcionalidades fornecidas, ainda apresentam algumas
limitações, tais como licenciamento, falta de documentação, poucos recursos
para utilizadores inexperientes, dificuldades a nível de programação avançada,
entre outras. Outra situação que surge é a inexistência de plataformas para
algumas linguagens muito utilizadas nas áreas de ensino e de inteligência
artificial, tais como a linguagem Pascal e a linguagem Prolog, respectivamente.
Como tal, surge a necessidade de uma plataforma mais abrangente, quer a nível
de documentação, quer a nível de linguagens, que consiga satisfazer as
necessidades de programadores mais exigentes sem, no entanto, descurar
programadores iniciantes, que pretendam usufruir ao máximo do Kit Lego®
Mindstorms® NXT. Nesse contexto surge a plataforma Droide M.L.P., que
pretende ser uma ferramenta orientada a programadores, quer iniciantes, quer
avançados, que pretendam evoluir os seus conhecimentos a nível de algoritmia e
programação na área de robótica necessitando, para tal, de uma plataforma que
disponibilize um leque mais vasto de linguagens para escolha, bem como
manuais e actividades com resolução para auxiliar na programação do Kit Lego®
Mindstorms® NXT [22].
3.3. PROJECTO DROIDE UMA
Nestes últimos anos, começou a ser a aceite que aprender não é meramente
uma actividade individual, isolada de factores sociais e culturais. Na realidade, a
aprendizagem ocorre num contexto social, que influencia e é influenciado por
tipos de práticas e conhecimentos que são construídos. Assim sendo, não
podemos negligenciar o mundo onde os estudantes vivem - um mundo cada vez
mais informatizado e, consequentemente, mais em contacto com a matemática.
O que é importante aprender não é o mesmo que na altura em que pais eram
29
alunos. A evolução da capacidade técnica dos equipamentos de computação e as
possibilidades das comunicações por rede trouxeram novas dimensões de
trabalho e novas possibilidades. No entanto, a maior parte das salas de aulas
ainda não reflecte estes avanços. [23]
O ensino de conceitos informáticos tem sido sempre um desafio, pois a
informática é uma área intelectualmente exigente e um grande número de
conceitos fundamentais precisa ser ensinado na sala de aula em relativamente
pouco tempo. Os métodos tradicionais de ensino tendem a favorecer as
abstracções, o que, frequentemente, faz com que os alunos tenham dificuldade
em compreender o comportamento dos programas informáticos e reconhecer a
relevância das tarefas que lhes são propostas. [24]
A utilização de robots como elementos mediadores entre o aluno e a Informática
é um tema pouco estudado em Portugal, pelo menos no contexto de sala de
aula. Assim, com o intuito de desenvolver investigação com a finalidade de
compreender de que forma o uso da robótica contribui para que os alunos
possam desenvolver a aprendizagem de tópicos e conceitos matemáticos e
informáticos e, se possível a articulação entre as duas áreas de conhecimento, foi
idealizado, no Departamento de Matemática e Engenharias da Universidade da
Madeira, o projecto DROIDE: “Os Robots como elementos mediadores entre os
alunos e a Matemática/Informática” iniciado no ano lectivo 2005/2006. [25]
O projecto tem como objectivos:
• Criar problemas na área da Matemática/Informática a serem resolvidos
através dos robots;
• Criar robots para abordar problemas específicos na área da
Matemática/Informática;
• Implementar a resolução de problemas utilizando robótica em três tipos
de sala de aula:
o De matemática no ensino básico e secundário;
o De informática no ensino secundário;
30
o De Inteligência Artificial (Licenciatura em Engenharia Informática),
Didáctica da Informação (Licenciatura de Ensino de Informática) e
Didáctica da Matemática (Mestrado em Matemática), no ensino
superior;
Em suma, este projecto pretende descrever, analisar e compreender como é que
os alunos aprendem Matemática /Informática tendo os robots como elementos
mediadores.
31
“We shall do a much better programming job, provided we approach the task with a full appreciation of its tremendous difficulty, provided
that we respect the intrinsic limitations of the human mind and
approach the task as very humble programmers.”
Alan Turing
32
4. NXT SOFTWARE DEVELOPMENT KIT
Neste capítulo será descrito o funcionamento e composição do núcleo da
plataforma Droide M.L.P., o NXT S.D.K. Serão abordadas as diversas constituintes
do mesmo, bem como serão justificadas as diferentes opções tomadas ao longo
do desenvolvimento do S.D.K.
4.1. MOTIVAÇÃO E OBJECTIVOS
Como mencionado no capítulo anterior, a plataforma Droide M.L.P. surge numa
tentativa de colmatar algumas das lacunas existentes nas diferentes plataformas
de programação para o Kit Lego® Mindstorms® NXT. Como tal, a motivação para
o desenvolvimento do NXT S.D.K. surge como sendo a necessidade de criar uma
fundação firme e saudável para o crescimento da plataforma Droide M.L.P.,
criando um núcleo potente e robusto, que permita a utilização de diversas
linguagens para a programação do Kit Lego® Mindstorms® NXT e, em simultâneo,
permita a sua expansão através da adição de novos módulos que, por sua vez,
irão trazer novas linguagens ou novas funcionalidades à plataforma. Como tal, é
possível identificar os seguintes objectivos para o NXT S.D.K.:
• Possibilitar uma comunicação sem falhas entre o bloco NXT e o
computador;
• Possibilitar a expansão da plataforma através da adição de novas
linguagens;
• Garantir consistência e coerência entre as bibliotecas desenvolvidas para
cada linguagem, através da utilização de uma estrutura semelhante de
desenvolvimento;
• Providenciar uma documentação correcta e actualizada, com vista a
facilitar a utilização e aprendizagem da plataforma.
33
4.2. ESTRUTURA DO S.D.K.
O NXT S.D.K., sendo o cerne da plataforma Droide M.L.P., é responsável por
garantir a comunicação entre o computador e o bloco NXT. Como tal, comporta
as bibliotecas necessárias para estabelecer e manter a comunicação com o bloco
NXT, nas linguagens especificadas, bem como em futuras linguagens que sejam
adicionadas à plataforma. Adicionalmente, é através das instalação do S.D.K. que
é possível localizar a nova firmware a inserir no bloco NXT, bem como os
controladores necessários para a correcta utilização do bloco. Como tal,
podemos definir a estrutura do S.D.K. da seguinte forma, tal como exemplifica a
Figura 6:
• Firmware – O NXT S.D.K. possui a nova firmware a ser instalada no bloco
NXT, substituindo a firmware original do Kit Lego® Mindstorms® NXT. Esta
será a firmware a utilizar pela plataforma Droide M.L.P.
• Interface.lua.conf – Camada de interface entre a firmware e as bibliotecas
de comunicação. Esta é necessária para a correcta comunicação com a
plataforma.
• Bibliotecas de comunicação – Consistem em duas bibliotecas,
implementadas em linguagens distintas, C++ e Java, que serão utilizadas
para comunicar com o bloco NXT. São parte essencial da plataforma e
foram criadas para garantir a compatibilidade com as linguagens de base
da mesma.
• Bibliotecas de controlo - Consistem em 4 bibliotecas, criadas para cada
uma das 4 linguagens base da plataforma, e que serão utilizadas para
permitir o controlo do bloco NXT via cada linguagem. Cada biblioteca
contém um conjunto de classes e métodos adequados ao funcionamento
do bloco.
34
Figura 6 - Estrutura do NXT S.D.K.
Será agora abordada cada componente da estrutura do NXT S.D.K. com mais
detalhe.
4.3. FIRMWARE UTILIZADA
Será discutido, nesta secção, qual a firmware utilizada e o porquê da escolha
desta. O objectivo será explicar, de forma sucinta, quais foram as razões que
levaram à escolha desta firmware e quais as suas vantagens e desvantagens
35
quando em comparação com outras firmwares disponíveis para o Kit Lego®
Mindstorms® NXT.
4.3.1. PBLUA
Uma das firmwares mais rápidas disponíveis para a programação do Kit Lego®
Mindstorms® NXT é a firmware pbLua. Tratando-se de uma firmware
desenvolvida de raiz por Ralph Hempel, que é um perito em firmwares [26], esta
representa, em simultâneo, uma plataforma e um ambiente de programação
integrado para o bloco NXT. Por outras palavras, a pbLua é uma firmware que
possui integrado um compilador e que permite a programação e execução de
código directamente no bloco, sem que para tal seja necessário recorrer a
programas externos para o efeito. A linguagem de programação suportada pela
firmware é uma linguagem textual de nome Lua [26], que se trata de uma
linguagem leve e rápida, com suporte multi-paradigma. Foi desenhada como
uma linguagem de scripting, com suporte à extensibilidade e com uma sintaxe
simples de trabalhar. Uma das suas vantagens é o facto de não ser uma
linguagem rígida, possibilitando a sua extensão para a resolução de problemas
mais complexos [27].
Apesar de se tratar de uma firmware ainda em fase beta, é considerada uma das
firmwares mais rápidas para a programação do Kit Lego® Mindstorms® NXT [9].
Adicionalmente, é uma firmware em constante crescimento sendo que, num
período de um ano já foi fruto de actualizações importantes, tais como a adição
de um sistema de ficheiros [26]. Trata-se de uma firmware poderosa, capaz de
suportar já todas as funcionalidades base do Kit Lego® Mindstorms® NXT, tal
como a leitura de sensores, quer estes sejam os sensores originais da Lego ou
sensores de outros fabricantes, movimentos de motores, comunicação por
Bluetooth (embora a comunicação ainda se encontre em fase experimental),
leitura e escrita no ecrã LCD do bloco, entre outras funcionalidades. Possui
também uma documentação extensa e um razoável conjunto de tutoriais,
permitindo a um utilizador, com uma certa experiencia em programação,
36
começar a programar o Kit Lego® Mindstorms® NXT sem muitas dificuldades. A
programação em si terá que ser feita através de ligação remota ao bloco,
utilizando um programa como, por exemplo, o Hyperterminal, fornecido
gratuitamente com o Windows XP.
Devido ao mencionado anteriormente, esta foi a firmware de eleição para o NXT
S.D.K. Tratando-se de uma firmware poderosa, rápida e em constante evolução,
esta firmware provou satisfazer os requisitos base procurados, que foram:
• Possibilidade de comunicação com diferentes linguagens;
• Vasto leque de funções;
• Utilização gratuita;
• Eficiência na execução;
Como ponto negativo, é necessário possuir a plataforma Lego® Mindstorms®
NXT Software para poder instalar a firmware no bloco NXT. Este ponto, no
entanto, será um ponto a resolver em trabalhos futuros.
4.3.2. CAMADA DE COMUNICAÇÃO
Com vista a simplificar a comunicação entre a firmware seleccionada e as
bibliotecas de comunicação, foi desenvolvida uma pequena camada de
comunicação, de nome Interface.lua.conf. Esta consiste essencialmente num
conjunto de funções a executar pelo bloco que, por sua vez, serão chamadas
directamente pelas bibliotecas de comunicação, abordadas mais à frente. Os
objectivos principais desta camada foram:
• Minimizar a comunicação entre o bloco e as bibliotecas de comunicação,
com vista a evitar possíveis falhas;
• Permitir a chamada de funções mais complexas directamente a partir do
bloco, visto seria muito complexo e ineficiente fazer o mesmo processo a
partir das bibliotecas de comunicação;
37
• Aproveitar a velocidade da firmware, fazendo com que certas operações
sequenciais sejam executadas pelo bloco NXT e não pelas bibliotecas de
comunicação.
Na Figura 7, podemos ver um excerto do código utilizado no desenvolvimento da
camada de comunicação. De notar que esta foi programada utilizando a
linguagem de programação Lua, que é a linguagem de programação nativa da
firmware pbLua.
lua = {}
ultrarray = {}
nxt.I2Cversion = string.char( 0x02, 0x00 )
nxt.I2Cproduct = string.char( 0x02, 0x08 )
nxt.I2Ctype = string.char( 0x02, 0x10 )
nxt.I2Ccontinuous = string.char( 0x02, 0x41, 0x02 )
nxt.I2Cdata = string.char( 0x02, 0x42 )
-- Used to configure the sensor associated with the given port
function lua.Configure (id_port, sensor_type)
if(string.lower(sensor_type)=="light") then
nxt.InputSetType(id_port,1)
nxt.InputSetDir(id_port,1,0)
nxt.InputSetState(id_port,1,0)
return 0
end
if(string.lower(sensor_type)=="touch") then
nxt.InputSetType(id_port,0)
nxt.InputSetDir(id_port,0,0)
nxt.InputSetState(id_port,0,0)
return 0
end
if(string.lower(sensor_type)=="sound") then
nxt.InputSetType(id_port,1)
nxt.InputSetDir(id_port,1,0)
nxt.InputSetState(id_port,1,0)
return 0
end
if(string.lower(sensor_type)=="ultrasound") then
nxt.InputSetType(id_port,2)
nxt.InputSetDir(id_port,1,1)
nxt.InputSetState(id_port,1,1)
nxt.I2CInitPins(id_port)
table.insert(ultrarray,id_port)
return 0
end
end
Figura 7 - Excerto de código da camada de comunicação
38
Como podemos ver através da Figura 7, temos uma função Configure, que
recebe somente dois argumentos. Ao ser invocada, esta executa, directamente
no bloco NXT, um conjunto sequencial de instruções, como podemos observar na
figura, com vista a configurar um tipo de sensor específico. Caso este conjunto
de instruções fosse executado pela biblioteca de comunicação e não pela
camada de comunicação, que se encontra inserida no bloco, tornar-se-ia numa
operação mais demorada e mais susceptível a falhas, devido ao número de
instruções a serem comunicadas. Assim sendo, é preferível minimizar a
complexidade das operações a serem transmitidas, maximizando o desempenho
e minimizando os erros gerados na comunicação.
Esta camada, no entanto, deve ser carregada imediatamente após a instalação e
configuração correcta da firmware e do bloco NXT, utilizando a ferramenta
Interface Loader, que será apresentada em seguida.
4.3.3. INTERFACE LOADER
Com o objectivo de carregar a camada de comunicação para o bloco NXT, foi
desenvolvida uma pequena aplicação em Java. Esta aplicação possui uma
interface gráfica de utilizador, como podemos ver através da Figura 8, e
necessita somente que lhe seja indicada a porta série virtual à qual o bloco NXT
se encontra associado. Feito este passo, é dado início ao processo e o utilizador
deve aguardar que o mesmo termine, sendo dada a indicação pela aplicação em
questão.
Figura 8 - Ecrã principal do Interface Loader
39
Esta ferramenta deve ser somente executada aquando a instalação da nova
firmware no bloco. Mais informações sobre a utilização desta ferramenta podem
ser encontradas nos anexos desta dissertação.
4.4. BIBLIOTECAS DE COMUNICAÇÃO
Seleccionada a firmware e implementada a camada de comunicação no bloco
NXT, torna-se necessário desenvolver as bibliotecas que irão garantir a
comunicação entre o bloco NXT e o computador que o utilizador irá recorrer na
programação do Kit Lego® Mindstorms® NXT. De notar que o bloco NXT terá que
se manter em constante comunicação com o computador, visto que a plataforma
Droide M.L.P. é considerada uma plataforma de controlo remoto, ou seja, todo o
código desenvolvido terá que ser compilado e executado na máquina e não no
bloco em si. Há que referir também que, de momento, a plataforma só suporta
comunicação por cabo USB, embora a comunicação por Bluetooth seja algo a
desenvolver em trabalhos futuros.
Assim sendo, serão agora explicadas as duas bibliotecas de comunicação
desenvolvidas para a plataforma Droide M.L.P., que se encontram inseridas no
NXT S.D.K.
4.4.1. BIBLIOTECA JAVA
A primeira biblioteca de comunicação desenvolvida foi a biblioteca para a
linguagem de programação Java. Esta biblioteca, que também foi desenvolvida
na linguagem Java e recorrendo ao editor opensource Eclipse, fez uso de uma
A.P.I. gratuita denominada Java Communications A.P.I. v2.x, A.P.I. esta que pode
ser utilizada pela plataforma Java para comunicações que utilizem a porta série
do computador, como é o caso da plataforma Droide M.L.P. A versão 2.x desta
A.P.I. não é a mais recente, mas é a única que ainda é possível encontrar para o
sistema operativo Windows XP, visto que a Sun® Microsystems® optou por
abandonar o desenvolvimento da mesma para o sistema operativo indicado.
40
Como tal, esta A.P.I. foi incluída no NXT S.D.K., com vista à correcta comunicação
com o bloco NXT, e foi criada a biblioteca de comunicação com o nome de
CommJava.jar, que faz uso da Java Communications A.P.I. v2.x
Esta biblioteca contêm somente uma classe, de nome SerialCommunication, que
possui um conjunto de métodos que pretendem simplificar e tornar transparente
todo o processo de comunicação com o bloco NXT. É possível encontrar a
documentação da biblioteca em anexo, com vista a melhor compreender os
métodos disponibilizados pela mesma. A Figura 9 mostra-nos um excerto de
código da classe implementada.
41
package CommJava; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintStream; import javax.comm.CommPortIdentifier; import javax.comm.NoSuchPortException; import javax.comm.PortInUseException; import javax.comm.SerialPort; import javax.comm.UnsupportedCommOperationException; /** * SerialCommunication.java - Class used to establish the * communication to the NXT block. * * @author Helder Pestana and Octavia Figueira * @version 1.5 */
public class SerialCommunication { public static final int DATABITS_5 = 5; public static final int DATABITS_6 = 6; public static final int DATABITS_7 = 7; public static final int DATABITS_8 = 8; public static final int PARITY_EVEN = 2; public static final int PARITY_MARK = 3; public static final int PARITY_NONE = 0; public static final int PARITY_ODD = 1; public static final int PARITY_SPACE = 4; public static final int STOPBITS_1 = 1; public static final int STOPBITS_1_5 = 3; public static final int STOPBITS_2 = 2; private boolean isPortDefined; private boolean isPortOpen; private boolean isPortReadable; private boolean isPortWritable; private static CommPortIdentifier portId; private String portName; private SerialPort serialPort; private BufferedReader readFromPort; private PrintStream writeToPort; /**
* Constructs an instance of a SerialCommunication channel * with the NXT block
*/
public SerialCommunication() { isPortDefined = false; isPortOpen = false; isPortReadable = false; isPortWritable = false; portName = "not defined"; portId = null; serialPort = null; readFromPort = null; writeToPort = null; JavaxComm.printerInit(); }
Figura 9 – Excerto de código da biblioteca de comunicação Java
42
Como podemos ver na Figura 9, a classe SerialCommunication importa o pacote
javax.comm, que é o pacote fornecido pela Java Communications A.P.I. v2.x para
a comunicação através da porta série. No entanto, é da responsabilidade da
biblioteca de comunicação Java a implementação dos métodos que serão
utilizados pelas bibliotecas de controlo para comunicar com o bloco NXT.
Podemos observar, na Figura 10, um diagrama de classes, que exemplifica como
está estruturada internamente a biblioteca de comunicação Java.
4.4.2. BIBLIOTECA C++
Após desenvolvida a biblioteca de comunicação para a linguagem Java, surgiu a
necessidade de desenvolver uma biblioteca de comunicação para a linguagem
C++, que seguisse a mesma estrutura que a biblioteca sua antecessora. Tal
deveu-se ao facto de que, inicialmente, o NXT S.D.K. tinha como objectivo a
CommJava.jar Java Communications
A.P.I. v2.x
SerialCommunication
setPort(port); openPort(); setPortParameters(baudrate, dataBits, stopBits, parity); setPortWritable(); setPortReadable(); writeToPort(textToWrite); readFromPort(); getPortName(); isPortOpen(); isPortReadable(); isPortWritable(); flushStream(); closePort();
«imports»
Figura 10 - Diagrama de classes da biblioteca de comunicação Java
43
implementação de somente duas linguagens base, as linguagens C++ e Java.
Como tal, e visto que se tratam de duas linguagens distintas, foi optado por
desenvolver duas bibliotecas de comunicação, uma para cada uma das
linguagens. Para o efeito foi utilizado o I.D.E. Visual C++ Express Edition 2005,
que se trata de um I.D.E. com licença gratuita para o Windows XP, bem como um
S.D.K. específico para o desenvolvimento de bibliotecas (no caso do C++ são
chamadas de dll’s) para a linguagem C++ e não só, o Windows Server 2003 R2
Platform SDK. Este S.D.K. permite a implementação de dll’s utilizando a versão Express
do C++, bem como adiciona um conjunto de bibliotecas base para o desenvolvimento de
módulos ou bibliotecas para as linguagens C++, C++/CLI, C#, entre outras. Uma outra
opção para o desenvolvimento da biblioteca pretendida seria a utilização do Visual
Studio 2005, que é um I.D.E. mais completo e poderoso e que contêm as bibliotecas
oferecidas pelo Windows Server 2003 R2 Platform SDK, mas que, em contrapartida,
necessita de uma licença paga para a sua utilização. Como tal, foi optado pela primeira
opção.
Instalado o I.D.E. Visual C++ Express Edition e o Windows Server 2003 R2 Platform SDK,
foi procedido à implementação da biblioteca em questão, atribuindo-lhe o nome
CommCpp.dll e seguindo sempre os moldes da biblioteca anterior já desenvolvida. Como
tal, foi também implementada na biblioteca uma classe denominada
SerialCommunication, que possui um conjunto de métodos que pretende simplificar e
tornar transparente o processo de comunicação com o bloco NXT. É possível
encontrar a documentação da biblioteca em anexo, com vista a melhor
compreender os métodos disponibilizados pela mesma. A Figura 11 mostra-nos
um excerto de código da classe implementada.
44
#include "stdafx.h" #define TEST_EXPORTS #include "CommCpp.h" using namespace Communication; SerialCommunication::SerialCommunication(){ _isPortDefined = false; _isPortOpen = false; } SerialCommunication::~SerialCommunication(){} int SerialCommunication::setPort(std::string port){ portName.assign(port); _isPortDefined = true; return 0; } int SerialCommunication::openPort(){ if(!_isPortDefined){ perror("COMUNICATION ERROR #1: Port wasn't defined yet.\n"); return -1; } serialPort = CreateFile(portName.c_str(), GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
if (serialPort == INVALID_HANDLE_VALUE){ perror("COMUNICATION ERROR #2: Port doesn't exist or is already in use.\n");
return -1; } PurgeComm(serialPort,PURGE_RXCLEAR); _isPortOpen = true; return 0; } int SerialCommunication::setPortParameters(int baudrate, int dataBits, int stopBits, int parity){ if(!_isPortOpen){ perror("COMUNICATION ERROR #3: Port isn't open.\n"); return -1; } if (!GetCommState(serialPort, &portConfiguration)){ perror("COMUNICATION ERROR #4: Could not get existing port parameters.\n"); return -1; } portConfiguration.BaudRate = baudrate; portConfiguration.ByteSize = dataBits; portConfiguration.StopBits = stopBits; portConfiguration.Parity = parity; portConfiguration.fBinary = true; if (!SetCommState(serialPort, &portConfiguration)) { perror("COMUNICATION ERROR #5: Invalid port parameters.\n"); return -1; }
Figura 11 - Excerto de código da biblioteca de comunicação C++
45
Como foi mencionado para o caso da biblioteca de comunicação em Java,
também é da responsabilidade da biblioteca de comunicação em C++ a
implementação dos métodos que serão utilizados pelas bibliotecas de controlo
para comunicar com o bloco NXT. No entanto, tal não seria possível caso não
fosse instalado o Windows Server 2003 R2 Platform SDK, como já referido
anteriormente. Este instala um conjunto de bibliotecas, tais como a cstdlib e a iostream,
que são utilizadas pela biblioteca de comunicação em C++ e que, sem as quais, não é
possível garantir o funcionamento da comunicação na linguagem C++. Podemos
observar, na Figura 12, um diagrama de classes, que exemplifica como está
estruturada internamente a biblioteca de comunicação C++.
CommCpp.dll Windows Server 2003
R2 Platform SDK
SerialCommunication
setPort(port); openPort(); setPortParameters(baudrate, dataBits, stopBits, parity); writeToPort(textToWrite); readFromPort(); getPortName(); isPortOpen(); isPortDefined(); closePort();
«imports»
Figura 12 - Diagrama de classes da biblioteca de comunicação C++
46
4.5. BIBLIOTECAS DE CONTROLO
Implementadas as bibliotecas de comunicação, torna-se necessária a
implementação de bibliotecas que permitam efectivamente controlar o bloco
NXT, pois as anteriores bibliotecas permitem somente estabelecer comunicação
com o bloco e não o seu controlo. Como tal, foram desenvolvidas inicialmente
duas bibliotecas para o efeito, que foram implementadas nas linguagens de
programação C++ e Java, sendo depois desenvolvidas duas bibliotecas de
extensão para o suporte das linguagens de programação C# e Vb.Net. Serão
agora apresentadas cada uma das bibliotecas desenvolvidas.
4.5.1. BIBLIOTECA JAVA
Tal como as bibliotecas de comunicação, a primeira biblioteca de controlo a ser
implementada foi a biblioteca para a linguagem de programação Java.
Desenvolvida na linguagem de programação Java e recorrendo ao editor
opensource Eclipse, esta biblioteca, de nome NxtJava.jar, implementa um
conjunto extenso de métodos para um melhor controlo do bloco NXT.
Contendo duas classes para o efeito, a classe NXTBlock e a classe NXTCodeBlocks,
a biblioteca de controlo Java possibilita um controlo mais rudimentar e flexível,
através da classe NXTBlock, e um controlo mais robusto e inflexível, através da
classe NXTCodeBlocks. Por outras palavras, a classe NXTBlock foi desenvolvida a
pensar numa aproximação mais básica mas, em simultâneo, capaz de
providenciar ao programador maior liberdade de expressão a nível de algoritmia
e controlo do bloco. Fornecendo um conjunto extenso de funções básicas, o
programador pode depois extender a classe com vista a criar uma estrutura mais
adequada ao pretendido. Por outro lado, a classe NXTCodeBlocks foi criada a
pensar num programador menos experiente. Funcionando como extensão da
classe NXTBlock, a classe NXTCodeBlocks implementa, como o próprio nome
indica, uma estrutura mais rígida, através de blocos de código que executam
funções mais complexas.
47
Por exemplo, utilizando a classe NXTBlock para executar uma operação simples
como mover o robot uma volta para a frente, será necessário invocar a função
moveMotor, que possui como argumentos o motor a movimentar, a velocidade
pretendida e o número de graus a executar pelo motor. Esta função terá que ser
chamada para cada um dos motores. No caso da classe NXTCodeBlocks, será
necessário utilizar as funções setMotors, que é utilizada para definir os motores
utilizados no movimento, e forwardTurns, que necessita somente da velocidade
e número de voltas a executar.
Adicionalmente, a segunda classe implementa tratamento de erros, com vista a
garantir a correcta utilização dos motores, ao passo que a primeira não tem essa
opção implementada. Como tal, a segunda possui uma estrutura mais definida e
rígida, provendo menor liberdade ao programador, mas tornando a programação
do Kit Lego® Mindstorms® NXT mais acessível. Em anexo, é possível encontrar a
documentação da biblioteca de controlo Java, contendo informações sobre
todos os métodos e classes implementados pela mesma. A Figura 13 mostra-nos
um excerto do código utilizado na implementação da classe NXTBlock.
48
Figura 13 - Excerto de código da biblioteca de controlo Java
Como é possível ver na figura acima, a classe NXTBlock recorre à biblioteca de
comunicação Java, já mencionada acima. Tal leva a que o processo de
comunicação seja mais transparente e fácil de compreender, bem como a
estrutura seguida para comunicação com o bloco se encontre melhor definida. É
package Nxt.Java; import CommJava.*; import Exceptions.Java.*; /** * NXTBlock - Class used to operate NXT block. * * @author Hélder Pestana and Octávia Figueira * @version 2.7 */
public class NXTBlock { private boolean isNXTInitialized; private boolean isPortSet; private SerialCommunication luaCommChannel; private String reading; /** * Constructs an instance of the NXTBlock. */
public NXTBlock() { isNXTInitialized = false; isPortSet = false; luaCommChannel = null; } /** * Sets the communication channel to be used by the class. * @param portName The port name. */
public void setCommChannel(String portName) { luaCommChannel = new SerialCommunication(); luaCommChannel.setPort(portName); isPortSet = true; } /** * Opens the communication channel to be used by the class. */
protected void openCommChannel() { luaCommChannel.openPort(); luaCommChannel.setPortParameters(38400,
49
possível verificar que a classe também implementa os seus próprios métodos de
comunicação, baseados nos métodos de comunicação definidos pela biblioteca
de comunicação, com vista a reduzir o código necessário invocar para
comunicação, facilitando todo o processo.
Podemos observar, na Figura 14, um diagrama de classes, que melhor
exemplifica como está estruturada internamente a biblioteca de controlo para a
linguagem Java, mostrando a relação existente entre a biblioteca de controlo e a
biblioteca de comunicação, bem como a relação entre as classes pertencentes à
biblioteca de controlo.
NxtJava.jar
CommJava.jar
NXTBlock
setCommChannel(portName); initializeNXT(); moveMotor(motor, speed, degrees); isStopped(motor); stopMotor(motor); configure(port, sensorType); read(port); speed(motor); isPlaying(); play(melody, volume); clear(); flip(); invert(); scroll(); write(text); shutdown(); reboot(); reflash(); battery();
«uses»
NXTCodeBlocks
«imports all functions implemented in NXTBLock»
setMotors(leftmotor, rightmotor); move(motor, speed); moveDegrees(motor, speed, degrees); moveTurns(motor, speed, turns); moveTime(motor, speed, miliseconds); forward(speed); forwardTurns(speed, turns); forwardDegrees(speed, degrees); forwardTime(speed, miliseconds); backward(speed); backwardTurns(speed, turns); backwardDegrees(speed, degrees); backwardTime(speed, miliseconds); stop(); turnLeft(speed); turnLeftTurns(speed, turns); turnLeftDegrees(speed, degrees); turnLeftTime(speed, miliseconds); turnRight(speed); turnRightTurns(speed, turns); turnRightDegrees(speed, degrees); turnRightTime(speed, miliseconds); setUltrasoundSensor( id_port); setLightSensor(id_port); setTouchSensor(id_port); setSoundSensor(id_port); (…)
«extends»
Figura 14 - Diagrama de classes da biblioteca de controlo Java
50
4.5.2. BIBLIOTECA C++
Implementada a biblioteca de controlo em Java, procedeu-se à implementação
da biblioteca de controlo para a linguagem de programação C++. Desenvolvida
na linguagem de programação C++ e recorrendo ao editor gratuito Visual C++
Express Edition 2005, esta biblioteca, de nome NxtCpp.dll, implementa um
conjunto extenso de métodos para um melhor controlo do bloco NXT através da
linguagem C++.
Contendo duas classes para o efeito, a classe NXTBlock e a classe NXTCodeBlocks,
a biblioteca de controlo C++ possibilita um controlo mais rudimentar e flexível,
através da classe NXTBlock, e um controlo mais robusto e inflexível, através da
classe NXTCodeBlocks. Por outras palavras, a classe NXTBlock foi desenvolvida a
pensar numa aproximação mais básica mas, em simultâneo, capaz de
providenciar ao programador maior liberdade de expressão a nível de algoritmia
e controlo do bloco. Fornecendo um conjunto extenso de funções básicas, o
programador pode depois extender a classe com vista a criar uma estrutura mais
adequada ao pretendido. Por outro lado, a classe NXTCodeBlocks foi criada a
pensar num programador menos experiente. Funcionando como extensão da
classe NXTBlock, a classe NXTCodeBlocks implementa, como o próprio nome
indica, uma estrutura mais rígida, através de blocos de código que executam
funções mais complexas. Adicionalmente, esta implementa tratamento de erros,
com vista a garantir a correcta utilização dos motores, ao passo que a primeira
não tem essa opção implementada. Como tal, possui uma estrutura mais
definida e rígida, provendo menor liberdade ao programador, mas tornando a
programação do Kit Lego® Mindstorms® NXT mais acessível. Em anexo, é possível
encontrar a documentação da biblioteca de controlo C++, contendo informações
sobre todos os métodos e classes implementados pela mesma. A Figura 15
mostra-nos um excerto do código utilizado na implementação da classe
NXTBlock.
51
Figura 15 - Excerto de código da biblioteca de controlo C++
Como é possível ver na figura acima, a classe NXTBlock recorre à biblioteca de
comunicação C++, já mencionada acima. Tal leva a que o processo de
comunicação seja mais transparente e fácil de compreender, bem como a
estrutura seguida para comunicação com o bloco se encontre melhor definida. É
possível verificar que a classe também implementa os seus próprios métodos de
comunicação, baseados nos métodos de comunicação definidos pela biblioteca
#define TEST_EXPORTS #include "NxtCpp.h" using namespace Communication; using namespace Exceptions::Cpp; using namespace Nxt::Cpp; NXTBlock::NXTBlock() { _isNXTInitialized = false; _isPortSet = false; luaCommChannel = new SerialCommunication(); } NXTBlock::~NXTBlock() { delete luaCommChannel; } void NXTBlock::setCommChannel(string portName) { luaCommChannel->setPort(portName); _isPortSet = true; } void NXTBlock::openCommChannel() { luaCommChannel->openPort(); luaCommChannel->setPortParameters(38400,8,1,0); } void NXTBlock::closeCommChannel() { luaCommChannel->closePort(); } void NXTBlock::writeToChannelPort(std::string textToWrite) { luaCommChannel->writeToPort(textToWrite); } string NXTBlock::readFromChannelPort() { return luaCommChannel->readFromPort(); }
52
de comunicação, com vista a reduzir o código necessário invocar para
comunicação, facilitando todo o processo.
Podemos observar, na Figura 16, um diagrama de classes, que melhor
exemplifica como está estruturada internamente a biblioteca de controlo para a
linguagem C++, mostrando a relação existente entre a biblioteca de controlo e a
biblioteca de comunicação, bem como a relação entre as classes pertencentes à
biblioteca de controlo.
CommCpp.dll
NXTBlock
setCommChannel(portName); initializeNXT(); moveMotor(motor, speed, degrees); isStopped(motor); stopMotor(motor); configure(port, sensorType); read(port); speed(motor); isPlaying(); play(melody, volume); clear(); flip(); invert(); scroll(); write(text); shutdown(); reboot(); reflash(); battery();
«uses»
NXTCodeBlocks
«imports all functions implemented in NXTBLock»
setMotors(leftmotor, rightmotor); move(motor, speed); moveDegrees(motor, speed, degrees); moveTurns(motor, speed, turns); moveTime(motor, speed, miliseconds); forward(speed); forwardTurns(speed, turns); forwardDegrees(speed, degrees); forwardTime(speed, miliseconds); backward(speed); backwardTurns(speed, turns); backwardDegrees(speed, degrees); backwardTime(speed, miliseconds); stop(); turnLeft(speed); turnLeftTurns(speed, turns); turnLeftDegrees(speed, degrees); turnLeftTime(speed, miliseconds); turnRight(speed); turnRightTurns(speed, turns); turnRightDegrees(speed, degrees); turnRightTime(speed, miliseconds); setUltrasoundSensor( id_port); setLightSensor(id_port); setTouchSensor(id_port); setSoundSensor(id_port); (…)
«extends»
NxtCpp.dll
Figura 16 - Diagrama de classes da biblioteca de controlo C++
53
4.5.3. BIBLIOTECA C#
Implementadas a bibliotecas de controlo anteriores, surgiu a ideia de
implementar uma nova linguagem no NXT S.D.K., a linguagem C#. Tendo em
conta que se trata de uma nova linguagem de programação, desenvolvida para
trabalhar com a plataforma .NET, e que possui já imensos adeptos, devido à sua
facilidade e potencial, a linguagem C# representou um excelente desafio para
adicionar à plataforma. Como tal, procedeu-se ao estudo e implementação da
biblioteca de controlo para a linguagem de programação C#. Desenvolvida na
linguagem de programação C++/CLI e recorrendo ao editor gratuito Visual C++
Express Edition 2005, esta biblioteca, de nome NxtCs.dll, implementa um
conjunto extenso de métodos para um melhor controlo do bloco NXT através da
linguagem C#. De notar que esta biblioteca possui uma caracteristica particular,
que é o facto de que recorrer a um pattern especificio, o pattern Adapter, com
vista a transformar a biblioteca de controlo do C++ numa biblioteca de controlo
para a linguagem C#.
Contendo duas classes para o efeito, a classe NXTBlock e a classe
NXTCodeBlocks, a biblioteca de controlo C# possibilita um controlo mais
rudimentar e flexível, através da classe NXTBlock, e um controlo mais robusto e
inflexível, através da classe NXTCodeBlocks. Fornecendo um conjunto extenso de
funções básicas, o programador pode depois extender a classe com vista a criar
uma estrutura mais adequada ao pretendido. Por outro lado, a classe
NXTCodeBlocks foi criada a pensar num programador menos experiente.
Funcionando como extensão da classe NXTBlock, a classe NXTCodeBlocks
implementa, como o próprio nome indica, uma estrutura mais rígida, através de
blocos de código que executam funções mais complexas. Adicionalmente, esta
implementa tratamento de erros, com vista a garantir a correcta utilização dos
motores, ao passo que a primeira não tem essa opção implementada. Como tal,
possui uma estrutura mais definida e rígida, provendo menor liberdade ao
programador, mas tornando a programação do Kit Lego® Mindstorms® NXT mais
54
acessível. Em anexo, é possível encontrar a documentação da biblioteca de
controlo C#, contendo informações sobre todos os métodos e classes
implementados pela mesma. A Figura 17 mostra-nos um excerto do código
utilizado na implementação da classe NXTBlock.
Figura 17 - Excerto de código da biblioteca de controlo C#
#include "stdafx.h" #include "NxtCs.h" using namespace System; Nxt::Cs::NXTBlock::NXTBlock() { this->NXTWrapper = new Nxt::Cpp::NXTBlock(); } Nxt::Cs::NXTBlock::~NXTBlock() { delete(this->NXTWrapper); } void Nxt::Cs::NXTBlock::setCommChannel(System::String ^portName) { this->NXTWrapper->setCommChannel(MarshalString(portName)); } void Nxt::Cs::NXTBlock::initializeNXT() { this->NXTWrapper->initializeNXT(); } void Nxt::Cs::NXTBlock::moveMotor(System::String ^motor, int speed, int degrees) { try { this->NXTWrapper->moveMotor(MarshalString(motor), speed, degrees); } catch (Exceptions::Cpp::InvalidSpeedException e) { throw gcnew Exceptions::Cs::InvalidSpeedException(); } catch (Exceptions::Cpp::InvalidMotorException e) { throw gcnew Exceptions::Cs::InvalidMotorException(); } catch (Exceptions::Cpp::PortIsNotSetException e) { throw gcnew Exceptions::Cs::PortIsNotSetException(); }
55
Como é possível ver na figura acima, a classe NXTBlock recorre à biblioteca de
controlo C++, já mencionada acima. Tal deve-se ao facto de esta utilizar o pattern
Adapter para a implementação dos seus métodos.
Podemos observar, na Figura 18, um diagrama de classes, que melhor
exemplifica como está estruturada internamente a biblioteca de controlo para a
linguagem C#, mostrando a relação existente entre a biblioteca de controlo C# e
a biblioteca de controlo C++, bem como a relação entre as classes pertencentes à
biblioteca de controlo.
56
Figura 18 - Diagrama de classes da biblioteca de controlo C#
4.5.4. BIBLIOTECA VB.NET
Implementadas a bibliotecas de controlo anteriores, surgiu a ideia de
implementar outra nova linguagem no NXT S.D.K., a linguagem Vb.Net Tendo em
conta que se trata de uma potente e melhorada linguagem (predecessora do
Vb), desenvolvida para trabalhar com a plataforma .NET, e que possui imensos
adeptos, devido à sua facilidade e potencial, a linguagem Vb.Net representou um
excelente desafio para adicionar à plataforma. Como tal, procedeu-se ao estudo
e implementação da biblioteca de controlo para a linguagem de programação
Vb.Net. Desenvolvida na linguagem de programação C++/CLI e recorrendo ao
NxtCpp.dll
NXTBlock
setCommChannel(portName); initializeNXT(); moveMotor(motor, speed, degrees); isStopped(motor); stopMotor(motor); configure(port, sensorType); read(port); speed(motor); isPlaying(); play(melody, volume); clear(); flip(); invert(); scroll(); write(text); shutdown(); reboot(); reflash(); battery();
«adaptes»
NXTCodeBlocks
«imports all functions implemented in NXTBLock»
setMotors(leftmotor, rightmotor); move(motor, speed); moveDegrees(motor, speed, degrees); moveTurns(motor, speed, turns); moveTime(motor, speed, miliseconds); forward(speed); forwardTurns(speed, turns); forwardDegrees(speed, degrees); forwardTime(speed, miliseconds); backward(speed); backwardTurns(speed, turns); backwardDegrees(speed, degrees); backwardTime(speed, miliseconds); stop(); turnLeft(speed); turnLeftTurns(speed, turns); turnLeftDegrees(speed, degrees); turnLeftTime(speed, miliseconds); turnRight(speed); turnRightTurns(speed, turns); turnRightDegrees(speed, degrees); turnRightTime(speed, miliseconds); setUltrasoundSensor( id_port); setLightSensor(id_port); setTouchSensor(id_port); setSoundSensor(id_port); (…)
«extends»
NxtCs.dll
57
editor gratuito Visual C++ Express Edition 2005, esta biblioteca, de nome
NxtVbNet.dll, implementa um conjunto extenso de métodos para um melhor
controlo do bloco NXT através da linguagem Vb.Net. De notar que esta biblioteca
possui uma caracteristica particular, que é o facto de que recorrer a um pattern
especificio, o pattern Adapter, com vista a transformar a biblioteca de controlo
do C++ numa biblioteca de controlo para a linguagem Vb.Net.
Contendo duas classes para o efeito, a classe NXTBlock e a classe NXTCodeBlocks,
a biblioteca de controlo Vb.Net possibilita um controlo mais rudimentar e
flexível, através da classe NXTBlock, e um controlo mais robusto e inflexível,
através da classe NXTCodeBlocks. Fornecendo um conjunto extenso de funções
básicas, o programador pode depois extender a classe com vista a criar uma
estrutura mais adequada ao pretendido. Por outro lado, a classe NXTCodeBlocks
foi criada a pensar num programador menos experiente. Funcionando como
extensão da classe NXTBlock, a classe NXTCodeBlocks implementa, como o
próprio nome indica, uma estrutura mais rígida, através de blocos de código que
executam funções mais complexas. Adicionalmente, esta implementa
tratamento de erros, com vista a garantir a correcta utilização dos motores, ao
passo que a primeira não tem essa opção implementada. Como tal, possui uma
estrutura mais definida e rígida, provendo menor liberdade ao programador,
mas tornando a programação do Kit Lego® Mindstorms® NXT mais acessível. Em
anexo, é possível encontrar a documentação da biblioteca de controlo Vb.Net,
contendo informações sobre todos os métodos e classes implementados pela
mesma. A Figura 19 mostra-nos um excerto do código utilizado na
implementação da classe NXTBlock.
58
Figura 19 - Excerto de código da biblioteca de controlo VbNet
Como é possível ver na figura acima, a classe NXTBlock recorre à biblioteca de
controlo C++, já mencionada acima. Tal deve-se ao facto de esta utilizar o pattern
Adapter para a implementação dos seus métodos.
Podemos observar, na Figura 20, um diagrama de classes, que melhor
exemplifica como está estruturada internamente a biblioteca de controlo para a
linguagem Vb.Net, mostrando a relação existente entre a biblioteca de controlo
#include "stdafx.h" #include "NxtCs.h" using namespace System; Nxt::VbNet::NXTBlock::NXTBlock() { this->NXTWrapper = new Nxt::Cpp::NXTBlock(); } Nxt::VbNet::NXTBlock::~NXTBlock() { delete(this->NXTWrapper); } void Nxt::VbNet::NXTBlock::setCommChannel(System::String ^portName) { this->NXTWrapper->setCommChannel(MarshalString(portName)); } void Nxt::VbNet::NXTBlock::initializeNXT() { this->NXTWrapper->initializeNXT(); } void Nxt::VbNet::NXTBlock::moveMotor(System::String ^motor, int speed, int degrees) { try { this->NXTWrapper->moveMotor(MarshalString(motor), speed, degrees); } catch (Exceptions::Cpp::InvalidSpeedException e) { throw gcnew Exceptions::VbNet::InvalidSpeedException(); } catch (Exceptions::Cpp::InvalidMotorException e) { throw gcnew Exceptions::VbNet::InvalidMotorException(); } catch (Exceptions::Cpp::PortIsNotSetException e) { throw gcnew Exceptions::VbNet::PortIsNotSetException();
59
Vb.Net e a biblioteca de controlo C++, bem como a relação entre as classes
pertencentes à biblioteca de controlo.
Figura 20 - Diagrama de classes da biblioteca de controlo VbNet
NxtCpp.dll
NXTBlock
setCommChannel(portName); initializeNXT(); moveMotor(motor, speed, degrees); isStopped(motor); stopMotor(motor); configure(port, sensorType); read(port); speed(motor); isPlaying(); play(melody, volume); clear(); flip(); invert(); scroll(); write(text); shutdown(); reboot(); reflash(); battery();
«adaptes»
NXTCodeBlocks
«imports all functions implemented in NXTBLock»
setMotors(leftmotor, rightmotor); move(motor, speed); moveDegrees(motor, speed, degrees); moveTurns(motor, speed, turns); moveTime(motor, speed, miliseconds); forward(speed); forwardTurns(speed, turns); forwardDegrees(speed, degrees); forwardTime(speed, miliseconds); backward(speed); backwardTurns(speed, turns); backwardDegrees(speed, degrees); backwardTime(speed, miliseconds); stop(); turnLeft(speed); turnLeftTurns(speed, turns); turnLeftDegrees(speed, degrees); turnLeftTime(speed, miliseconds); turnRight(speed); turnRightTurns(speed, turns); turnRightDegrees(speed, degrees); turnRightTime(speed, miliseconds); setUltrasoundSensor( id_port); setLightSensor(id_port); setTouchSensor(id_port); setSoundSensor(id_port); (…)
«extends»
NxtVbNet.dll
60
1. As a software project approaches release, its mass
increases.
2. The energy required to release a software project is
inversely proportional to the time before a scheduled release.
3. It takes infinite energy to release a finished product on
time; therefore, all software projects are both incomplete and late.
4. Time is relative to the observer of a software project. The
last month of development appears to an outside observer
to take a year. 5. If a software project becomes too large, it will collapse into
a black hole. Time and money are absorbed but nothing
ever comes out.
Brian Russell's Laws of Software Relativity (cf. Belady and
Lehman's Laws of Software Evolution)
61
5. CONCLUSÃO
Levando em conta todo o trabalho de investigação desenvolvido ao longo desta
dissertação, ficam algumas notas e conclusões retiradas.
5.1. TRABALHO DESENVOLVIDO
A plataforma Droide M.L.P. representa um trabalho colaborativo entre dois
alunos em conclusão dos seus mestrados. Como tal, parte deste trabalho, que
corresponde ao desenvolvimento do NXT S.D.K., foi apresentado ao longo desta
dissertação, enquanto outra parte será apresentada na dissertação da aluna de
mestrado Octávia Raquel Gomes Figueira, parte essa correspondendo à
potencialização da plataforma através do desenvolvimento de novos módulos e
de actividades para a plataforma.
5.2. TRABALHO FUTURO
Actualmente, a plataforma Droide M.L.P. ainda se trata de um projecto
embrionário, necessitando ainda de alguma investigação e melhoramentos, com
vista a tornar esta plataforma numa ferramenta potente para a programação do
Kit Lego® Mindstorms® NXT. Não obstante, já possui imenso potencial, pois já
permite a programação do Kit Lego® Mindstorms® NXT, providenciando ao seu
utilizador imensas ferramentas para o efeito. Como trabalhos futuros, é
pretendido:
• Suporte à comunicação Bluetooth entre bloco e computador;
• Desenvolvimento de um I.D.E. próprio;
• Actualização / Melhoramento da firmware utilizada;
• Adição de novas funcionalidades à plataforma.
62
5.3. CONCLUSÕES FINAIS
O Kit Lego® Mindstorms® NXT apresenta um enorme potencial para o utilizador
que se pretenda iniciar na área da robótica. Possuindo uma boa plataforma de
software, denominada de Lego® Mindstorms® NXT Software, o Kit é muito útil
para utilizadores iniciantes. No entanto, no caso de utilizadores que pretendam
desenvolver algo mais complexo recorrendo ao Kit Lego® Mindstorms® NXT,
especialmente no que toca à programação do Kit, estes irão se deparar com um
ambiente de desenvolvimento algo limitado, pois a plataforma fornecida é uma
plataforma que utiliza uma V.P.L. para o desenvolvimento de aplicações. Como
tal, apresenta algumas limitações. No entanto, existem inúmeras plataformas
disponíveis para a programação do Kit Lego® Mindstorms® NXT, quer gratuitas,
quer pagas, que disponibilizam imensos recursos para o desenvolvimento de
soluções de programação mais complexas que aquelas permitidas pela
plataforma de origem.
A plataforma Droide M.L.P. insere-se neste meio, surgindo como mais uma
plataforma para a programação do Kit Lego® Mindstorms® NXT, mas com
características inovadoras, tais como suporte multi-linguagens. Adicionalmente,
esta possui vastos recursos a nível de tutoriais e manuais, o que a torna indicada
para um utilizador que já tenha alguma experiência em programação, pois irá
fornecer a este um conjunto de métodos e classes, próprias para a programação
do Kit Lego® Mindstorms® NXT. Esta plataforma, por sua vez, pode ser utilizada
na área de ensino, especialmente no ensino de inteligência artificial, visto que
inclui a linguagem de programação Prolog, uma linguagem muito utilizada na
área de inteligência, devido à sua facilidade na expressão de predicados lógicos.
Há que concluir mencionando que esta plataforma é um projecto recente, com
potencial para um maior crescimento. Como tal, projectos futuros irão envolver
uma comunicação mais bem estruturada, utilizando já as funcionalidades
Bluetooth do bloco, bem como um I.D.E. próprio para a plataforma.
63
BIBLIOGRAFIA
[1] Robot - Wikipedia, the free encyclopedia. Wikipedia, the free encyclopedia. [Online]
06 08, 2008. [Cited: 06 09, 2008.] http://en.wikipedia.org/wiki/Robot.
[2] What does Robotics teach students ? Kid Technic - Robotics Enrichment for teachers
and students. [Online] 2006. http://www.kidtechnic.com/forparents.taf?vnav=schools.
[3] Robotics - Wikipedia, the free encyclopedia. Wikipedia, the free encyclopedia.
[Online] 06 06, 2008. [Cited: 06 08, 2008.] http://en.wikipedia.org/wiki/Robotics.
[4] Nourbakhsh, Illah R., Robots and Education in the classroom and in the museum.
Pittsburgh : The Robotics Institute Carnegie Mellon University.
[5] Lego Mindstorms NXT - Wikipedia, the free encyclopedia. Wikipedia, the free
encyclopedia. [Online] 06 11, 2008. [Cited: 06 12, 2008.]
http://en.wikipedia.org/wiki/Lego_Mindstorms_NXT.
[6] Sharad, Shekhar., Introducing Embedded Design Concepts to Freshmen and
Sophomore Engineering Students with LEGO MINDSTORMS NXT. s.l. : National
Instruments Academic Group.
[7] Carnegie Mellon, Robotics Academy., "RobotCLego." [Online] 2007.
http://wiki.mytimeworld.com/files/attachments/documents/ROBOTClego.pdf.
[8] Carnegie Mellon., ROBOTC.net. ROBOTC.net. [Online] http://www.robotc.net/.
[9] Hassenplug, Steve., NXT Programming Software. NXT Programming Software.
[Online] http://www.teamhassenplug.org/NXT/NXTSoftware.html.
[10] E., Matt., Programming the NXT. MindSquawl. [Online]
http://mindsquawl.blogspot.com/2007/02/programming-nxt-choice-choice-
choice_04.html.
[11] Scholz, Matthias Paul., RobotC. RobotC. [Online]
http://mynxt.matthiaspaulscholz.eu/book/excerpts/robotc.html.
[12] LEGO.com MINDSTORMS Press NXT. LEGO.com MINDSTORMS Press
NXT:Mindstorms Software Announcement. [Online] 06 11, 2006.
http://mindstorms.lego.com/press/2057/Mindstorms%20Software%20Announcement.a
spx.
[13] LEGO.com MINDSTORMS. LEGO.com MINDSTORMS Overview:. [Online]
http://mindstorms.lego.com/Overview/NXT_Software.aspx.
64
[14] Visual programming language - Wikipedia, the free encyclopedia. Wikipedia, the
free encyclopedia. [Online] 06 12, 2008. [Cited: 06 14, 2008.]
http://en.wikipedia.org/wiki/Visual_programming_language.
[15] LEGO Education., Writing Efficient NXT-G Programs. s.l. : LEGO Education, 2006.
[16] Yocum, Dale., Essentials. NXT Tutorial. [Online]
http://www.ortop.org/NXT_Tutorial/html/essentials.html.
[17] leJOS - Wikipedia, the free encyclopedia. Wikipedia, the free encyclopedia. [Online]
06 15, 2008. [Cited: 06 16, 2008.] http://en.wikipedia.org/wiki/LeJOS.
[18] LeJOS, Java for Lego Mindstorms. NXJ technology. [Online]
http://lejos.sourceforge.net/p_technologies/nxt/nxj/nxj.php.
[19] Java (programming language) - Wikipedia, the free encyclopedia. Wikipedia, the
free encyclopedia. [Online] 06 15, 2008. [Cited: 06 16, 2008.]
http://en.wikipedia.org/wiki/Java_(programming_language).
[20] Eclipse - an open development platform. Eclipse.org home. [Online]
http://www.eclipse.org/.
[21] Eclipse (software) - Wikipedia, the free encyclopedia. Wikipedia, the free
encyclopedia. [Online] 06 13, 2008. [Cited: 06 14, 2008.]
http://en.wikipedia.org/wiki/Eclipse_(software).
[22] Droide Multi Language Platform. 2008.
[23] Fernandes, Elsa, Fermé, Eduardo and Oliveira, Rui., Using Robots to Learn Functions
in Math Class.
[24] Santos, Elci Alcione, Fermé, Eduardo and Fernandes, Elsa., UTILIZAÇÃO DE ROBOTS
NO ENSINO DE PROGRAMAÇÃO: O PROJECTO DROIDE. 2007.
[25] Gaspar, Luis Alberto da Silva., Os Robots nas Aulas de Informática - Plataformas e
Problemas. 2007.
[26] Hempel, Ralph., pbLua Home Page. pbLua Home Page. [Online] 2008.
[27] Lua (programming language) - Wikipedia, the free encyclopedia. Wikipedia, the free
encyclopedia. [Online] 06 16, 2008. [Cited: 06 16, 2008.]
http://en.wikipedia.org/wiki/Lua_(programming_language).
65
Anexo A – Documentação das Bibliotecas
66
Anexo B – Manual de Instalação do NXT S.D.K
67
Anexo C – Manuais de Configuração das
Linguagens