Este trabalho apresenta o ROBOTEC, uma ferramenta desenvolvida para apoiar o ensino de lógica de programação utilizando um braço robótico. O ROBOTEC integra aspectos dinâmicos e estáticos de algoritmos em uma única ferramenta com comandos em português baseados no pseudocódigo Portugol. A ferramenta permite visualizar a execução de algoritmos em tempo real através dos movimentos do braço robótico Lynxmotion AL5D.

1. UNIVERSIDADE DO ESTADO DE SANTA CATARINA – UDESC
CENTRO DE EDUCAÇÃO DO PLANALTO NORTE – CEPLAN
BACHARELADO EM SISTEMAS DE INFORMAÇÃO
MAGNO RONAN RITZMANN
SÃO BENTO DO SUL, SC
2012
ROBOTEC:
UMA FERRAMENTA DE APOIO AO ENSINO DE LÓGICA DE PROGRAMAÇÃO

2. MAGNO RONAN RITZMANN
ROBOTEC:
UMA FERRAMENTA DE APOIO AO ENSINO DE LÓGICA DE PROGRAMAÇÃO
Trabalho de conclusão de curso apresentado para o
Curso de Bacharelado em Sistemas de Informação
da Universidade do Estado de Santa Catarina como
requisito para obtenção do grau de Bacharel em
Sistemas de Informação.
Orientador: Doutor Antônio Carlos Tamanini da
Silva
SÃO BENTO DO SUL, SC
2012

3. MAGNO RONAN RITZMANN
ROBOTEC:
UMA FERRAMENTA DE APOIO AO ENSINO DE LÓGICA DE PROGRAMAÇÃO
Trabalho de Conclusão de Curso II, como requisito para a aprovação na disciplina de
Trabalho de Conclusão de Curso II – TCC202 e como requisito para obtenção do grau de
Bacharel em Sistemas de Informação pela Universidade do Estado de Santa Catarina –
UDESC, Centro de Educação do Planalto Norte - CEPLAN.
Examinadores: Conceito:
Orientador:
Doutor: Antônio Carlos Tamanini da Silva
Universidade do Estado de Santa Catarina – UDESC
Professor/Moderador:
Doutor: Nilson Ribeiro Modro
Universidade do Estado de Santa Catarina - UDESC
Membro:
Mestre: Alex Luiz de Souza
Universidade do Estado de Santa Catarina – UDESC
Membro:
Mestre: Nelcimar Ribeiro Modro
Universidade do Estado de Santa Catarina – UDESC
SÃO BENTO DO SUL, SC
28/11/2012

4. Dedico este trabalho a minha família, que
sempre batalhou pela minha formação
acadêmica.

5. AGRADECIMENTOS:
Ao orientador Doutor, Antônio Carlos Tamanini da Silva, pela orientação, valiosas
sugestões e estímulo ao desenvolvimento deste trabalho.
A professora Shirley Souza pela revisão ortográfica deste trabalho.
A minha namorada Juciane Vanessa Rosa pela compreensão e paciência.
A todos que de alguma forma contribuíram com este trabalho, por se dedicarem a
mim, por não somente terem me ensinado, mas me feito aprender. Há tantos, então, sem
nominar terão meu eterno agradecimento.

6. “O Verdadeiro sinal de inteligência não é
o conhecimento, mas a imaginação.”
Albert Einstein

7. RESUMO
A maior dificuldade na concepção e no entendimento de algoritmos está em como entender as
estruturas dinâmicas das possíveis execuções de um algoritmo a partir de sua estrutura
estática. A linguagem definida no ROBOTEC visa auxiliar o processo de aprendizagem do
aluno iniciante em programação, integrando os aspectos dinâmicos e estáticos em uma só
ferramenta desenvolvida através de softwares livres e que possui atualmente vinte e nove
comandos em português, constituindo um interpretador de comandos que utiliza uma
derivação do “Portugol” - pseudo-linguagem de programação. O ROBOTEC integra ainda na
nesta versão, nove barras deslizantes para movimentação do braço robótico e o módulo
Álgebra, que executa o cálculo de movimentos válidos e rotas para movimentação do braço
robótico a posições determinadas pelo utilizador. O ROBOTEC fornece uma visualização em
tempo real da execução do algoritmo desenvolvido pelo usuário através da movimentação do
braço robótico Lynxmotion AL5D. O interpretador ROBOTEC é uma ferramenta gratuita e
possui código aberto, permitindo aos interessados o desenvolvimento de novas
funcionalidades, desde que mantida a filosofia inicial do mesmo e mencionadas ás autorias.
PALAVRAS-CHAVE: Algoritmos, Programação, Robótica.

8. ABSTRACT
The greatest difficulty in the development and understanding of algorithms is on how to
understand the dynamic structures of the possible executions of an algorithm from its static
structure. The language defined in the Robotec aims to assist the learning process of
beginning students programming, integrating dynamic and static aspects in one tool
developed with free software. The Robotec has twenty-nine commands in Portuguese, forming
a command interpreter that uses a derivation of "Portugol" - pseudo-language-programming
and this version also includes, nine sliders to move the robotic arm and the Algebra module,
which performs the calculation of valid moves and routes for the movement of the robotic arm
positions determined by the user. The Robotec provides a real-time view of the
implementation of the algorithm developed through the movement of the robotic arm
Lynxmotion AL5D. The Robotec is an open source software allowing stakeholders to develop
new features, since maintained of initial philosophy of it and mentioned the authorship.
Key-Words: Algorithms, Programming, Robotics.

9. LISTA DE ILUSTRAÇÕES
Figura 1 - Diagrama de bloco simplificado da modelagem da cinemática ..............................22
Figura 2 - DH Atribuição de quadros.......................................................................................23
Figura 3 - Quadro de ligação do braço robótico AL5D............................................................24
Figura 4 - Quadro de coordenadas do braço robótico AL5D ...................................................26
Figura 5 – Fórmula do ângulo de giro do braço robótico AL5D..............................................29
Figura 6 - Identificação de ângulos e juntas do braço robótico AL5D.....................................30
Figura 7 - Interface inicial do software RIOS ..........................................................................32
Figura 8 - Inteface do módulo controlador...............................................................................34
Figura 9 - Interface do módulo interpretador ...........................................................................37
Figura 10 - Sintaxe de declaração de variável..........................................................................38
Figura 11 – Inteface do módulo matemático............................................................................40
Figura 12 - Visões da arquitetura de software..........................................................................44
Figura 13 - Diagrama de Casos de uso.....................................................................................44
Figura 14 - Diagrama de Sequência .........................................................................................46
Figura 15 - Diagrama de Comunicação....................................................................................47
Figura 16 - Diagrama de estados..............................................................................................47
Figura 17 - Diagrama de Componentes....................................................................................48
Figura 18 - Diagrama de Implantação......................................................................................48
Figura 19 - Interface principal, menu "Aquivos" .....................................................................50
Figura 20 - Interface principal, menu "Edit" ............................................................................51
Figura 21 - Interface principal, menu "Help"...........................................................................52
Figura 22 - Interface principal, aba Controle ...........................................................................53
Figura 23 - Interface principal, aba Álgebra.............................................................................54
Figura 24 - Interface principal, aba Programa..........................................................................55

10. LISTA DE TABELAS
Tabela 1 - Parâmetros DH para o braço robótico AL5D..........................................................26
Tabela 2 - Propriedades do braço robótico AL5D....................................................................30
Tabela 3 - Funções de componentes da interface de controle..................................................34
Tabela 4 - Tabela de Lexemas da linguagem entendida do G-Portugol...................................36
Tabela 5 - Tabela de Sintaxe da linguagem entendida do G-Portugol.....................................36
Tabela 6 - Tabela de classificação de requisitos......................................................................43
Tabela 7 - Tabela de detalhamento do caso de uso ..................................................................45

11. LISTA DE ABREVIATURAS OU SIGLAS
IDE Integrated Development Environment
JDK Java Development Kit
JVM Java Virtual Machine
PBL Problem-Based Learning
UML Universal Modeling Language
DH Denavit – Hartenber
DOF Degrees Of Freedom
CTAR
RAM
MB
Centros de Tecnologia de Aplicações Robóticas
Random access memory
Megabyte

12. SUMÁRIO
1 INTRODUÇÃO............................................................................................................13
1.1 PROBLEMA ................................................................................................................14
1.2 OBJETIVOS.................................................................................................................14
1.2.1 Objetivo geral ...............................................................................................................14
1.2.2 Objetivos específicos....................................................................................................14
1.3 JUSTIFICATIVA.........................................................................................................15
1.4 CONTRIBUIÇÕES ......................................................................................................15
1.5 METODOLOGIA.........................................................................................................16
1.6 LIMITAÇÕES..............................................................................................................16
1.7 ESTRUTURA DO TRABALHO.................................................................................17
2 FUNDAMENTAÇÃO TEÓRICA ...............................................................................18
2.1 PSEUDOCÓDIGO PORTUGOL.................................................................................18
2.2 LÓGICA DE PROGRAMAÇÃO.................................................................................18
2.3 ALGORITMOS............................................................................................................19
2.4 ROBÓTICA..................................................................................................................19
2.4.1 Robótica Educacional...................................................................................................20
2.5 ÁLGEBRA ...................................................................................................................21
2.6 CINEMÁTICA.............................................................................................................21
2.6.1 A cinemática do braço robótico AL5D.........................................................................23
2.6.2 Cinemática direta..........................................................................................................26
2.6.3. Cinemática inversa .......................................................................................................29
2.7 Ferramenta controladora existente ...............................................................................31
3 DESENVOLVIMENTO...............................................................................................33
3.1 DESCRIÇÃO DO MODELO.......................................................................................33
3.1.1 Módulo controlador......................................................................................................33
3.1.2 Módulo interpretador....................................................................................................35
3.1.2.1 Declaração de variáveis................................................................................................37
3.1.2.2 Interpretação do código ................................................................................................38
3.1.3 Módulo matemático......................................................................................................39
3.1.4 Comunicação do braço robótico...................................................................................40
3.2 PROJETO DO SISTEMA ............................................................................................41
3.3 REQUISITOS DO PROTÓTIPO.................................................................................42

13. 3.3.1 Visões da arquitetura de software.................................................................................44
3.4 ESTRUTURA DO SISTEMA PROPOSTO ................................................................48
3.5 TELAS DO PROTÓTIPO............................................................................................49
3.6 FERRAMENTAS COMPUTACIONAIS UTILIZADAS ...........................................55
3.6.1 O Java ...........................................................................................................................56
4 ANÁLISE DOS RESULTADOS.................................................................................57
4.1 DESEMPENHO ...........................................................................................................57
4.2 LIMITAÇÕES DO SISTEMA.....................................................................................57
5 CONSIDERAÇÕES FINAIS .......................................................................................58
REFERÊNCIAS .....................................................................................................................59
GLOSSÁRIO ..........................................................................................................................62
APÊNDICE A – Diagrama de classes do sistema................................................................63
APÊNDICE B – Manual de operação do software ROBOTEC.........................................64

14. 13
1 INTRODUÇÃO
A primeira disciplina que envolve programação nos cursos de engenharia é
denominada comumente de: Introdução à Ciência da Computação, ou Programação para
Engenharia, ou Lógica de Programação, ou Processamento de Dados. Esta disciplina tem o
objetivo de apresentar uma visão geral da ciência da computação aplicada ao curso de
Engenharia, onde ao final da disciplina o acadêmico deverá ser capaz de implementar
algoritmos computacionais que envolvam estrutura de dados simples, controle de fluxo e
modularização. Como ementa, é comum abordar: conceitos básicos, representação de dados,
Algoritmos e Programação, e Modularização de algoritmos.
Com intuito de melhorar o aprendizado dos acadêmicos desta disciplina, buscou-se
pressupostos na literatura e em cursos de Ciência da Computação e, foi constatado que há
diversos livros específicos de ensino de algoritmos, lógica e estruturas de dados, que utilizam
linguagens em pseudocódigo Portugol ou português estruturado para o ensino básico de
programação (DASGUPTA, PAPADIMITRIOU & VAZIRANI, 2009; GUIMARÃES &
LAGES, 1985; MANZANO & OLIVEIRA, 2002). Relatos demonstram que tal abordagem
melhora a fixação e a assimilação de conteúdo por parte dos acadêmicos, uma vez que eles
devem se preocupar em aprender somente a lógica de programação e não outra linguagem
como C, C++, Java entre outras.
Segundo as Diretrizes Curriculares do Ministério da Educação
(http://www.mec.gov.br/), um estudante de computação raciocina de forma diferente de
outros profissionais porque possui a habilidade de construir algoritmos como soluções de
problemas. Portanto, ao desenvolver um projeto que seja ao mesmo tempo estimulante e
desafiador o estudante assimila maior conhecimento.
A aprendizagem Baseada em Problemas ou PBL – Problem Based Learning é uma
alternativa promissora para utilização junto com ferramenta desenvolvida, pois, além de
propiciar maior entendimento permite métodos lúdicos de ensino como o alinhamento de
dominós, empilhamento de blocos etc.
A PBL foi criada na Universidade de McMaster por professores de Medicina e em
pouco tempo se espalhou em muitas universidades, atualmente é reconhecida como um
método moderno e educativo, que visa que o aluno aprenda por si próprio (RIBEIRO
&MIZUKAMI, 2004).

15. 14
1.1 PROBLEMA
Considerando as dificuldades encontradas pelos alunos dos cursos da área de ciências
exatas na resolução de problemas via computador, e consequentemente no aprendizado de
algoritmos, foi constatado que a construção de uma interface amigável envolvendo um braço
robótico, além de despertar a curiosidade dos alunos em temas como álgebra vetorial e
cinemática básica, melhora a assimilação do conteúdo por parte dos acadêmicos, uma vez que
eles devem se preocupar em aprender somente a lógica de programação e não outra
linguagem como C, C++, Java ou Delphi.
Este trabalho pretende responder a seguinte pergunta: Como criar uma ferramenta
computacional, capaz de mover um braço robótico através de algoritmos baseados em
pseudocódigo Portugol, de forma que auxilie no ensino da lógica de programação,
álgebra vetorial e cinemática básica?
1.2 OBJETIVOS
1.2.1 Objetivo geral
Criar uma ferramenta computacional capaz de mover um braço robótico e que
possibilite o ensino da lógica de programação, álgebra vetorial e cinemática básica através de
algoritmos baseados em pseudocódigo Portugol.
1.2.2 Objetivos específicos
Para concretizar o objetivo deste trabalho será necessário alcançar os seguintes
objetivos específicos:
a) Realizar a análise de requisitos do sistema proposto;
b) Realizar a modelagem do sistema através da UML;
c) Construir o software controlador do braço robótico;
d) Construir o interpretador de comandos;
e) Construir o módulo de cinemática direta e inversa;

16. 15
f) Construir a interface do sistema;
g) Programar o sistema proposto;
h) Validar o sistema através de testes com os usuários.
1.3 JUSTIFICATIVA
A ferramenta proposta neste trabalho permitirá o ensino de algoritmos, cinemática básica
e álgebra vetorial de forma agradável e interessante melhorando assim o desempenho dos
alunos, além da possível utilização em conjunto com métodos como a PBL. Em comparação
com ferramentas de ensino de lógica de programação existentes que utilizam formas lúdicas
como, o mindstorm da Lego Inc, esta ferramenta propicia mais do que o entendimento de
lógica via fluxogramas como o mindstorm, ela fornece uma maneira simples com aplicação
em diversas áreas, fazendo com que o ensino seja visto pelo aluno de uma forma diferente
melhorando o aprendizado. Desta forma, a construção da ferramenta se justifica pelo fato de
que não há relatos da existência de ferramentas livres similares ao modelo proposto. Em
relação à utilização da PBL, RIBEIRO & MIZUKAMI, 2004 dizem que é reconhecida como
um método moderno e educativo, visando que o aluno aprenda por si próprio. Com isso,
possibilitando ao aluno o desenvolvimento de suas habilidades e sinta-se livre para testá-las.
No que diz respeito ao ensino de forma lúdica, a liberdade de desenvolvimento e o braço
robótico trazem ao aluno métodos de aprendizado através de brincadeiras tornando o
aprendizado mais agradável.
1.4 CONTRIBUIÇÕES
Este trabalho contribui aos cursos na área de sistemas de informação com uma nova
forma de ensino de algoritmos e de conceitos básicos em álgebra. Mas as contribuições deste
trabalho não se restringem apenas ao curso de sistemas de informação, pois é possível
abranger diversas áreas, podendo ser aplicado em outros cursos e em matérias relacionadas às
ciências exatas presentes em escolas de educação média e básica.
Para que este trabalho se faça útil, vindo a contribuir é necessário que seja utilizado
em conjunto com técnicas de ensino as quais motivem o espírito inquisitivo nos estudantes, de
forma que em sua aplicação o estudante interesse-se, promovendo um melhor aprendizado.

17. 16
1.5 METODOLOGIA
Este trabalho foi desenvolvido seguindo o modelo proposto por (SILVA e MENEZES,
2000). Classificando-se em quatro formas:
 Quanto à natureza, a pesquisa enquadra-se na classificação de pesquisa
aplicada, por pretender auxiliar no ensino de algoritmos, álgebra vetorial e
cinemática básica, de forma prática, através do desenvolvimento de uma
ferramenta computacional;
 Quanto à forma de abordagem do problema, pode ser classificada em
quantitativa ou qualitativa (SILVA e MENEZES, 2000, p. 20). Este trabalho
não possui características quantitativas, mas sim qualitativas. Uma vez que
propõe um modelo de ferramenta computacional a ser utilizado com intuito de
melhoria no ensino;
 Quanto aos objetivos, pode ser classificado em exploratória, descritiva ou
explicativa (SILVA e MENEZES, 2000. p. 21). Este trabalho possui
característica predominantemente exploratória, pois envolve procedimentos de
pesquisa bibliográfica e a aplicação de uma ferramenta computacional;
 Quanto aos procedimentos técnicos, este trabalho foi realizado respeitando o
procedimento técnico de pesquisa bibliográfica, já que ao identificar o tema do
trabalho realiza-se uma pesquisa bibliográfica, com consulta de livros,
periódicos nacionais e internacionais, dissertações e teses defendidas.
1.6 LIMITAÇÕES
A ferramenta computacional proposta neste trabalho é capaz apenas de mover um
braço robótico Lynxmotion modelo AL5D, através de comunicação serial em conjunto
com a utilização de interfaces interativas e comandos em pseudocódigo Portugol limitado
ao ensino da lógica de programação, álgebra vetorial e cinemática básica.

18. 17
1.7 ESTRUTURA DO TRABALHO
Este trabalho está estruturado em quatro capítulos. O Capítulo 1 apresenta aspectos
preliminares do trabalho. O Capítulo 2 apresenta o modelo proposto neste trabalho,
descrevendo as principais características do mesmo. O capítulo 3 descreve a construção da
ferramenta computacional. Nesse capítulo, ainda, descrevem-se os detalhes da construção do
protótipo. O capítulo 4 apresenta a análise dos resultados obtidos durante os testes da
ferramenta computacional desenvolvida.

19. 18
2 FUNDAMENTAÇÃO TEÓRICA
A Fundamentação Teórica é a base científica para o desenvolvimento de trabalhos
acadêmicos. A Fundamentação Teórica para este trabalho foca no desenvolvimento de uma
ferramenta computacional que auxilie no ensino de álgebra vetorial, cinemática básica e
principalmente lógica de programação, utilizando pseudocódigo Portugol e robótica.
2.1 PSEUDOCÓDIGO PORTUGOL
O Portugol é uma pseudo-linguagem algorítmica vastamente utilizada para a descrição
de algoritmos e destaca-se pelo uso de comandos em português, o que facilita o aprendizado
de lógica de programação, habituando o iniciante ao formalismo da programação. Portanto, os
algoritmos podem ser descritos em uma linguagem chamada de pseudocódigo.
O pseudocódigo é uma alusão a posterior implementação em uma linguagem de
programação, ou seja, quando formos programar em uma linguagem, por exemplo, JAVA,
estará gerando código em JAVA. Segundo (SALIBA, 1992, p. 6): "Esta forma de
representação de algoritmo é rica em detalhes, como a definição dos tipos das variáveis
usadas no algoritmo e, por assemelhar-se bastante à forma em que os programas são escritos,
encontra muita aceitação." Sendo assim os algoritmos são independentes das linguagens de
programação. Ao contrário de uma linguagem de programação, não existe um formalismo
rígido de como deve ser escrito o algoritmo. Um algoritmo deve ser fácil de interpretar e
codificar. Ou seja, ele deve ser o intermediário entre a linguagem “falada” e a linguagem de
programação.
2.2 LÓGICA DE PROGRAMAÇÃO
A lógica de programação é uma forma de se escrever um programa de computador
com uma linguagem de fácil entendimento para os seres humanos. A lógica de programação é
uma técnica utilizada para encadear pensamentos e atingir determinados objetivos, pois
permite definir uma sequência lógica para o desenvolvimento de programas sendo assim
necessária para todas as pessoas que desejam trabalhar com desenvolvimento de softwares.

20. 19
Um software ou programa de computador é na verdade um algoritmo escrito em uma
linguagem de computador como, por exemplo: Pascal, Java, Delphi, PHP, visual Basic etc.
2.3 ALGORITMOS
Segundo Wirth (1976, p. XII), Programas são formulações concretas de algoritmos
abstratos, baseados em representações e estruturas específicas de dados. Entende-se, portanto
que um algoritmo é formado por uma sequência lógica de passos ou procedimentos
necessários para a resolução de uma tarefa. Melhor dizendo, um algoritmo é uma sequência
lógica, finita e definida de instruções que devem ser seguidas para resolver um problema ou
executar uma tarefa. Podemos então comparar um algoritmo com uma receita culinária,
observando que esta possui uma sequência de instruções desde o início até uma meta
específica. E desta forma, a sequência não pode ser redundante e nem subjetiva na sua
definição, ela deve ser clara e precisa no decorrer e no resultado final.
Os algoritmos são muito utilizados na área de programação, descrevendo as etapas que
devem ser completadas para que um programa execute as tarefas que lhe são designadas.
Existem diversas formas de escrever um algoritmo como, por exemplo, o pseudocódigo (ou
português estruturado), fluxograma, diagrama de Chapin e descrição narrativa.
2.4 ROBÓTICA
A palavra ou termo “robô” no português é derivada pela palavra Checa “robota” a qual
faz menção a uma peça teatral do início de 1920, de autoria de Karel Capek, intitulada “Os
Robôs Universais de Rossum”. No vocabulário Checo a palavra “robota” significa servidão
ou trabalhador forçado. Desde então, o termo tem sido aplicado para uma grande variedade de
dispositivos mecânicos, ou seja, qualquer dispositivo que opere com algum grau de
autonomia. Segundo o Instituto de Robótica da América “Um robô é um manipulador
multifuncional reprogramável projetado para mover materiais, peças, ferramentas, ou
dispositivos especiais através de variáveis de movimentos programados para a realização de
uma variedade de tarefas.” (RIA) (SPONG, 1989). Encontramos ainda outras definições
como: “Um robô é um dispositivo mecânico controlado por software que usa sensores para
guiá-lo ou usa ferramentas na sua garra, que através de movimentos programados, dentro de

21. 20
um espaço de trabalho, manipula objetos físicos” (SCHILLING, 1990).
Existem diversos tipos de robôs. Os industriais, por exemplo, são projetados para
realizar trabalho produtivo. O trabalho é realizado pela habilidade do robô em mover seu
corpo, braço e punho através de uma série de movimentos e posições. O efetuador é uma
garra ou ferramenta a qual é foco de análise para os movimentos e é afixado na extremidade
oposta da base do robô. Tal efetuador é usado pelo robô para realizar uma tarefa específica
como girar, pegar ou soldar uma peça entre outras funções. Os movimentos individuais das
juntas normalmente são referenciados como graus de liberdade (DOF – Degrees Of Freedom).
Um robô industrial típico é equipado com 4 a 6 DOF. No qual normalmente três juntas são
associadas com a ação do braço e outras duas ou três são usadas para mover o efetuador.
2.4.1 Robótica Educacional
A Robótica Educacional, também conhecida como Robótica Pedagógica, é aplicada
em ambientes educacionais onde o aluno pode montar e desmontar um robô ou sistema
robotizado. Entretanto, somente com um braço robótico, não é necessário a montagem do
mesmo, focando ao ensino lúdico de lógica de programação baseado em problemas de
aprendizagem. Portanto, o padrão do uso da Robótica para ensino é mantido, mas alguns
conceitos bases são alterados.
A robótica educacional pode ser definida como a montagem de modelos e sistemas
robóticos, tendo como finalidade o aprendizado de conceitos científicos (física, matemática,
eletrônica, mecânica, etc.) entre outros por parte de quem realiza a montagem de tais sistemas
(ATTROT 2002).
Os Centros de Tecnologia de Aplicações Robóticas (CTAR) tem buscado criar um
ambiente de produção e geração de conhecimento entre pesquisadores e as empresas
interessadas na aplicação da tecnologia robótica, além de promover junto a instituições de
ensino, atividades científicas e empreendedoras, que possibilitem o contato direto de alunos e
professores, com aplicações robóticas em diversas áreas tais como: saúde, educação, varejo,
logística, segurança, defesa, entre outras. Os CTAR estão sempre buscando melhorar e
aperfeiçoar ferramentas educacionais baseadas na robótica para que fossem mais bem
utilizadas em sala de aula estimulando e otimizando o aprendizado dos alunos. Essas
ferramentas utilizam abordagem multidisciplinar e isso permite com que os alunos pratiquem
e consigam interagir entre as disciplinas técnicas, ou seja, entender eletrônica, física,

22. 21
matemática, mecânica e computação usando um único meio. Desta inter-relação de disciplinas
resulta um aprendizado mais rápido e permanente dos conceitos técnicos do que se tratados
separadamente.
Pode-se constatar que existem universidades além da Universidade do Estado de Santa
Catarina (UDESC) que estão adotando a robótica como ferramenta educacional. São os casos
das Universidades Federais do Mato Grosso do Sul (UFMS), do Rio Grande no Norte
(UFRN) e de Brasília (UNB). A UFMS adquiriu neste ano de 2012, em torno de 122 robôs
sendo 60 do modelo kids, 40 Curumins, 15 Sci-soccers e sete RoboDecks. A UFRN, em 2011,
adquiriu 15 Curumins e 1 RoboDeck e a UNB adquiriu 24 Curumins. Além da Universidade
Tecnológica Federal do Paraná (UTFPR) que adquiriu, até agora, 10 Sci-soccers e 5 Curumins
nos últimos anos.
2.5 ÁLGEBRA
A álgebra é o ramo da matemática que estuda as estruturas, as relações e as
quantidades. A álgebra elementar está relacionada às operações aritméticas (soma, subtração,
multiplicação, divisão). No entanto utiliza símbolos (x, y, z) em vez de números (1, 3, 6)
como na aritmética. Através da álgebra, podem-se formular leis gerais e fazer referência a
números desconhecidos (variáveis ou incógnitas), o que possibilita desenvolver equações e
análises correspondentes à sua resolução.
Para utilização junto ao modelo proposto a álgebra auxilia tanto na movimentação
básica do braço robótico quanto no ensino de seus conceitos aos utilizadores do mesmo. O
modelo proposto como descrito anteriormente se trata de uma ferramenta computacional. Esta
ferramenta, além de mover o braço robótico e possibilitar o ensino da lógica de programação,
provê uma maneira prática de ensinar conceitos de eixos, segmentos orientados, retas e
circunferências no R2
e no R3
, assim como outros assuntos possíveis de serem abordados com
os quais estejam relacionados ao espaço ortogonal.
2.6 CINEMÁTICA
No ramo da robótica, o estudo da cinemática provê uma análise dos movimentos do
robô em relação ao espaço geométrico, e alguns conceitos como: os tipos de movimentos dos

23. 22
robôs manipuladores, os tipos de juntas que os compõe, a relação de sua configuração ou
forma construtiva, e ainda o espaço geométrico que o robô pode atuar ou trabalhar são
necessários para alcançar desta forma sua movimentação adequada.
De acordo com KAY (2005) A cinemática na robótica é dividida em cinemática direta
e cinemática inversa. Onde a cinemática direta consiste em encontrar a posição do efetuador
(ou extremidade do braço) no espaço conhecendo os movimentos angulares de cada junta,
F(ϴ0, ϴ1, ..., ϴn) = [x, y, z, R], e a cinemática inversa determina a posição orientação de cada
junta correspondente a um valor de coordenadas cartesianas para que o efetuador final seja
capaz de alcançar, F(x, y, z, R) = (ϴ0, ϴ1, ..., ϴn). A Figura 1 retrata um diagrama de blocos
simplificado da modelagem da cinemática, este diagrama de blocos exibe a relação entre os
parâmetros geométricos, a posição final do efetuador e os movimentos das juntas do robô
calculados pelo estudo da cinemática.
Figura 1 - Diagrama de bloco simplificado da modelagem da cinemática
Fonte: O autor
É de uso comum à aplicação da teoria da atribuição de quadros de Denavit-Hartenberg
ou DH com referência em aplicações na robótica. Esta teoria, conforme na Figura 2, retrata
que a cada transformação homogênea Ti é representada como um produto de quatro
transformações básicas.

24. 23
Figura 2 - DH Atribuição de quadros
Fonte: O autor
Com isto segundo DH é possível retirar a equação Ti= Rot(z, θi)Trans(z, di)Trans(x,
ai)Rot(x, αi), onde a notação Rot( x , αi ) destaca a rotação sobre o eixo xi , a αi, Trans( x , ai )
destaca a translação ao longo do eixo xi com a distância α1, a Rot( z , θ1 ) destaca a rotação
sobre o eixo zi com θi , e Trans( z , di ) é a translação ao longo do eixo zi pela distância di. Os
quatro valores θi , ai , di , αi , são os parâmetros do vínculo i e da junta i, onde α tem referência
a distância entre as juntas, e d a distância da base com a primeira junta.
2.6.1 A cinemática do braço robótico AL5D
A cinemática direta determina com base na acumulação dos valores das juntas qual a
posição do efetuador final. Isso é possível desde que tenhamos os graus de inclinação de cada
junção do braço robótico. Para entender melhor suponhamos que um robô tenha n+1 junções
numeradas de zero a n começando pela base do robô, a qual é denominada como sendo a
junção número 0. As juntas são numeradas de 1 a n, e zi é um vetor unitário ao longo do eixo
no espaço sobre as junções i-1 e i interligadas. A última junta é denotada por q, no caso de
juntas revolutas como as encontradas no braço robótico Lynxmotion AL5D, q é o ângulo de
rotação. Enquanto, no caso de juntas prismáticas, q é a junta de translação. Um quadro de
coordenadas está rigidamente ligado a cada junção i, a Figura 3 ilustra a ideia das ligações das
juntas no caso de um braço robótico AL5D.

25. 24
Figura 3 - Quadro de ligação do braço robótico AL5D
Fonte: O autor
Ti
i-1
é uma matriz homogênea a qual é definida para transformar as coordenadas de um
ponto do quadro i para o quadro i-1. A matriz Ti
i-1
não é constante, pois suas variáveis mudam
a cada movimento do robô. No entanto, se assumirmos que todas as juntas são de rotação
(revolutas) ou deslizantes (prismáticas) significa que Ti
i-1
é uma função de apenas uma
simples variável de junta nomeada de qi , Ou seja Ti
i-1 =
Ti
i-1
(qi). A matriz homogênea que
transforma as coordenadas de um ponto de um quadro i, para o quadro j, é dada por Ti
j
(i>j).
Denotando a posição e orientação do efetuador final, o qual respeita a inércia ou o quadro da
base por um vetor d0
n e, uma matriz de rotação R0
n de 3x, respectivamente, definimos a matriz
homogênea:
Com isto a posição e orientação do efetuador final são dadas por:
Cada transformação homogênea de Ti
i-1
é na forma de:

26. 25
Consequentemente:
A matriz Ri
j
expressa à orientação do quadro i relativo ao quadro j (i > j) e é dado pelas partes
rotacionais de Ti
j
– matrizes (i > j) assim:
Os Vetores di
j
(i > j) são dados recursivamente pela fórmula:
O braço robótico AL5D possui cinco juntas rotacionais e uma garra móvel como
mostrado na Figura 3. A junta 1 representa o ombro e seu eixo de movimentação é z1. Essa
junta permite uma rotação angular θ1 pelo eixo z1 no plano x1y1. A Junta 2 é identificada
como braço e seu eixo é perpendicular ao eixo da junta 1. Isso fornece uma rotação angular θ2
pelo eixo z2 no plano x2y2. O eixo z3 da junta 3, o qual se refere ao antebraço e a junta 4, que
está relacionado ao pulso, são paralelos à junta 2 e eixo z. Eles fornecem movimentos
angulares θ3 e θ4 no plano x3y3 e x4y4, respectivamente. A junta 5 é identificada como rotação
da garra. Onde z5 é vertical a z4 e fornece movimento angular θ5 no plano x5y5 (QASSEM &
ABUHADROUS & ELAYDI, 2009). A Figura 4 mostra graficamente todas as juntas do
braço robótico AL5D.

27. 26
Figura 4 - Quadro de coordenadas do braço robótico AL5D
Fonte: O autor
2.6.2 Cinemática direta
Há muitos métodos que podem ser usados no cálculo da cinemática direta. A análise
de Denavit-Hartenberg é a mais utilizada. Neste método, a cinemática direta é determinada
por alguns parâmetros que devem ser definidos com base em cada mecanismo. Foi escolhido
para usar uma matriz de transformação homogênea nesta análise, uma vez que é possível
definir facilmente uma coordenada de transformação entre dois quadros em que a posição e
orientação são fixos um com relação ao outro, é possível trabalhar com operações
homogêneas elementares. A Tabela 1 retrata os parâmetros DH para o braço robótico AL5D.
Tabela 1 - Parâmetros DH para o braço robótico AL5D
i αi-1 ai-1 di θi
1 0 0 d1 θ1
2 90 0 0 θ2
3 0 a3 0 θ3
4 0 a4 0 (θ4-90)
5 -90 0 d5 θ5
6 0 0 0 Garra
Fonte: O autor

28. 27
Cada parâmetro tem seu significado junto ao braço robótico e estão descritos abaixo:
ai (Comprimento), é a distância de zi a zi+1 medida ao longo de zi;
αi (Torção), é o ângulo entre zi e zi+1, medido sobre xi;
di (Deslocamento), é a distância de xi a xi+1 medida ao longo de zi;
θi (Ângulo), é o ângulo entre xi e xi+1 medido sobre zi.
Através da substituição dos parâmetros da Tabela 1, na equação da matriz H de
transformação homogênea, que representa a rotação pelo ângulo α , sobre a posição atual do
eixo x, seguido pela translação das unidades ao longo deste mesmo eixo e pela translação de d
unidades, ao longo do eixo z e ainda seguido pela rotação do ângulo θ sobre este mesmo eixo
temos H, onde H é dado por: Rotz , α Transx , a Transz , d Rotz , θ.
As matrizes de transformação T1 à T6 podem ser obtidas como mostrado abaixo, por
exemplo, T1 mostra a transformação entre os quadros 0 e 1 ( designando Ci como cosseno de
θi, e Si como seno de θi).

29. 28
Usando os valores das transformações de matrizes acima, a transformação das junções
podem ser multiplicadas juntas para encontrar uma única transformação que retrate o quadro 5
para o quadro 0:
As transformações dadas pela equação acima é uma função de todas as 5 juntas
variáveis que resulta na posição cartesiana da última junção do robô no plano.
As primeiras três colunas da matriz representam a orientação do efetuador final,
enquanto que a última coluna representa a posição do mesmo (QASSEM & ABUHADROUS
& ELAYDI, 2009). É possível calcular a orientação e a posição do efetuador final em termos
de ângulos das juntas pelas seguintes equações:

30. 29
2.6.3. Cinemática inversa
Para resolver a cinemática inversa do braço robótico AL5D optou-se pelo modelo de
aproximação geométrica para sua resolução, ao passo que conhecemos os eixos XYZ e o
ângulo ao qual o pulso deverá se manter constantemente, também chamado de (Pitch),
começamos os cálculos pela rotação da base do braço robótico que é definida pela figura 5 e,
então segue-se para as demais juntas.
Figura 5 – Fórmula do ângulo de giro do braço robótico AL5D
Fonte: O autor
Para que seja possível o cálculo, definimos duas variáveis fictícias chamadas de X2d e
Y2d, as quais, na realidade, são os eixos X e Y vistos em duas dimensões. Assim, devemos,
então, calcular o Módulo formado pelos catetos X e Y (Figura 6). Após isso, definimos X2d e
Y2d, onde X2d=Módulo e Y2d =Z, onde Z é a variável, a qual define a altura do efetuador em
relação ao eixo X e Y. Antes de prosseguir com o restante dos cálculos das juntas j0, j1, j2,
devemos conhecer as propriedades do manipulador robótico, que estão descritas na Tabela 2.

31. 30
Tabela 2 - Propriedades do braço robótico AL5D
Servo Motor nº Referência Altura/Comprimento (mm)
0 Base 67.31
1 Braço 146.05
2 Antebraço 187.325
3 Pulso 100
4 Rotação do Pulso -
5 Garra -
Fonte: O autor
Com base nesta tabela é possível seguir com os cálculos, definimos então uma
variável chamada de Altura H, a qual recebe o valor da distância do ombro do braço robótico
ao solo. A partir da Figura 6 e dos dados obtidos até este ponto, torna-se possível identificar e
calcular o restante dos valores angulares das juntas.
Figura 6 - Identificação de ângulos e juntas do braço robótico AL5D
Fonte: O autor
Segue abaixo as fórmulas para os demais cálculos da cinemática inversa:
Afx = Cosseno (inclinação) * comprimento do pulso;

32. 31
Lado B = (AlvoX – Afx);
Afy = Seno (inclinação) *comprimento do pulso
Lado A = AlvoY –Afy – AlturaH;
2 2
Hipotenusa LadoA LadoB 
Alfa =
2 2
2arctan
LadoB
LadoA LadoB LadoA 
2 2 2
2* *
ComprimentodoBraço ComprimentodoAtebraço Hipotenusa
Beta ArcCos
ComprimentodoBraço Hipotenusa
 

2 2 2
2* *
Gamma
ComprimentodoBraço ComprimentodoAtebraço Hipotenusa
ArcCos
ComprimentodoBraço ComprimentodoAntebraço
 

Ang ombro =(Alfa + Beta);
Ang cotovelo = -(180 - Gamma);
Ang pulso = inclinação - Ang ombro – Ang cotovelo;
2.7 FERRAMENTA CONTROLADORA EXISTENTE
Lynxmotion, o fabricante do braço robótico AL5D, produziu para que viesse a ser
comercializada juntamente com seu hardware uma ferramenta controladora conhecida como
Robotic Arm Interactive Operating System ou RIOS, a Figura 7 ilustra sua interface inicial.
Esta ferramenta é capaz de mover os servos motores de forma individual e, também,
aceita como entrada, algoritmos limitados a apenas laços de execução. Este software possui
um simulador da cinemática dos robôs produzidos pela Lynxmotion.
Pelo fato desta ferramenta suportar diversos tipos de braços robóticos produzidos pela
Lynxmotion e não focar no ensino de lógica de programação, além de possuir uma interface
complexa para leigos em robótica, seu uso foi desaconselhado para a solução do problema do
ensino de algoritmos.

33. 32
Figura 7 - Interface inicial do software RIOS
Fonte: Lynxmotion

34. 33
3 DESENVOLVIMENTO
Neste capítulo, se encontra a descrição detalhada do modelo proposto e as funções
desempenhadas pelos módulos presentes nesta versão da ferramenta.
3.1 DESCRIÇÃO DO MODELO
O modelo proposto trata-se de uma ferramenta computacional capaz de mover o braço
robótico Lynxmotion AL5D, com a utilização de interface de controle, interface de
programação e interface algébrica.
A interface de controle contém barras deslizantes, as quais são capazes de mover
determinadas articulações do braço robótico. A interface de programação contém uma caixa
de texto na qual, algoritmos escritos em pseudocódigo Portugol são escritos e, posteriormente,
interpretados e executados pelo software. E a interface algébrica, na qual é possível, através
de coordenadas, mover o braço para posições específicas em um plano cartesiano, além de
executar funções de retas e círculos.
A comunicação entre o computador e o braço robótico ocorre por meio de interface
Serial, conhecida também como porta COM. Através da primeira aba do software, é possível
configurar a taxa de transmissão dos bits e a porta a ser utilizada. O Robotec, como foi
denominado o modelo proposto, foi desenvolvido para operar em microcomputador do tipo
PC (Personal Computer), sob o sistema operacional Windows. A subseção seguinte descreve
os módulos presentes no modelo.
3.1.1 Módulo controlador
O módulo controlador desenvolvido possui nove barras deslizantes, as quais
controlam o movimento dos servos motores, sua comunicação acontece diretamente com a
porta serial, sendo assim independente dos demais módulos. No entanto, o posicionamento do
braço robótico é restrito nesta interface, podendo-se apenas mover um servo motor de cada
vez devido a possível movimentação de uma barra deslizante por vez. A interface, além de
possuir uma barra deslizante para cada servo motor do braço robótico e uma para definição da
velocidade em que os servos motores se moverão, possui também duas barras desativadas

35. 34
para possíveis servos motores a serem adicionados fisicamente. A figura 8 ilustra a interface
do módulo controlador.
Figura 8 - Inteface do módulo controlador
Fonte: O autor
A função de cada componente da interface está listada na Tabela 3.
Tabela 3 - Funções de componentes da interface de controle
NOME SERVO-
MOTOR
FUNÇÃO RESTRIÇÃ
O
Motor 1 0 Responsável por enviar os bits, referentes à
movimentação da base do braço robótico para a
porta serial, está relacionada ao giro do braço por
completo.
0° a 180°
Motor 2 1 Responsável por enviar os bits, referentes à
movimentação do ombro (Shoulder) do braço
robótico para a porta serial, atua de forma vertical.
0° a 180°
Motor 3 2 Responsável por enviar os bits, referentes à
movimentação do cotovelo (Elbow) do braço
robótico para a porta serial, atua de forma vertical.
30° a 100°
Motor 4 3 Responsável por enviar os bits, referentes à 0° a 180°

36. 35
movimentação do pulso (Wrist) do braço robótico
para a porta serial, atua de forma vertical.
Motor 5 4 Responsável por enviar os bits, referentes ao giro
do pulso do braço robótico para a porta serial, está
relacionado ao giro do pulso.
0° a 180°
Motor 6 5 Responsável por enviar os bits referentes à
movimentação da garra (Grip) do braço robótico
para a porta serial, está relacionado ao movimento
de abrir e fechar a garra do efetuador.
0° a 180°
Motor 7 - Disponível para futuras modificações no braço
robótico.
-
Motor 8 - Disponível para futuras modificações no braço
robótico.
-
Velocidade - Define o intervalo de envio entre os bits de saída do
software.
-
Reiniciar 0,1,2,3,4,5 Envia para todos os servos-motores, os dados para
sua posição inicial.
-
Fonte: O autor
A função do botão “Reiniciar” é de fundamental importância, pois através dele é
possível reiniciar os servos-motores e mover de forma correta o braço robótico, visto que o
robô utilizado neste projeto não possui sensores que possibilitem o reconhecimento de sua
posição. Os servos motores são movidos através do envio de valores que representam os bits a
serem enviados ao chip controlador do braço robótico. A velocidade tem como função definir
uma variável relacionada ao tempo de espera entre o envio dos dados para a porta serial.
Dessa forma, a cada envio de novos movimentos o valor é dividido em movimentos unitários
pelo módulo controlador e, então, é enviado este valor bit a bit, movendo o braço até que este
alcance a posição definida.
3.1.2 Módulo interpretador
O Objetivo principal da ferramenta computacional Robotec é fornecer um apoio ao
ensino da lógica de programação baseado no Portugol, sem reduzir o estudo teórico. Para isto,
foi necessário o desenvolvimento deste módulo, que permite a digitação e a manipulação dos
arquivos que contém os algoritmos utilizando uma interface dirigida por menus e abas.

37. 36
Abaixo é exibida a Tabela 4 e a Tabela 5, ilustrando as palavras reservadas da linguagem
derivada do Portugol e as formas de uso para a construção dos algoritmos.
Tabela 4 - Tabela de Lexemas da linguagem entendida do G-Portugol
Lexemas Classificação
programa, movimentos, inicio_var, fim_var,
string, real, inteiro, se, entao, senao, fim_se para,
fim_para, faca, enquanto, fim_enquanto, inicio,
fim, adicionar_movimento, abre_garra,
fecha_garra, gira_base, move_ombro,
move_cotovelo, move_pulso, gira_pulso, imprima
Palavras Reservadas
+, -, *, / Operadores aritméticos
||, && Operadores lógicos
= Operador de atribuição
>, <, >=,<=, ==, != Operadores relacionais
//(comentários) Comentários
Fonte: O autor
Tabela 5 - Tabela de Sintaxe da linguagem entendida do G-Portugol
Comandos Sintaxe
Programa programa nome_do_programa;
movimentos, inicio, fim movimentos (espaço) inicio (comandos) fim
inicio_var, fim_var,
string, real, inteiro
inicio_var
string:nome_string=”valor”;
inteiro:nome_variavel=valor_inteiro;
real:nome_variavel= valor_real;
fim_var
se, então, senao, fim_se se(condição) entao (comando); senão (comando); fim_se
para, fim_para, faca, para(variavel=valor; condição);(incrementa ou decrementa
variável))faca (comando); fim_para
enquanto, fim_enquanto,
faca
enquanto(condição)faca
(comando);
fim_enquanto
adicionar_movimento adicionar_movimento(valor_inteiro, valor_inteiro, valor_inteiro);
abre_garra abre_garra(valor_inteiro);
fecha_garra fecha_garra();
gira_base gira_base(valor_inteiro);
move_ombro move_ombro(valor_inteiro);
move_cotovelo move_cotovelo(valor_inteiro);
move_pulso move_pulso(valor_inteiro);
gira_pulso gira_pulso(valor_inteiro);
Imprima imprima(variável) ou imprima(“string”);
// //comentário
Fonte: O autor

38. 37
A tabela de sintaxe da linguagem entendida do português estruturado (G-Portugol)
acima mostra como devem ser implementados os comandos isoladamente para formar um
algoritmo funcional, Contudo, vale ressaltar que o algoritmo deve seguir uma estrutura para
sua implementação. A estrutura em que os comandos devem estar digitados no editor do
programa do Robotec está ilustrado na Figura 9.
Figura 9 - Interface do módulo interpretador
Fonte: O autor
Entre os comandos inicio_var e fim_var são declaradas as variáveis a serem utilizadas
no algoritmo, e entre os comandos inicio e fim são adicionados os comandos para a
movimentação do braço robótico, os laços de repetição e os comandos de comparação.
3.1.2.1 Declaração de variáveis
Para a declaração das variáveis foram definidos alguns tipos básicos que são

39. 38
reconhecidos pelo interpretador, estes tipos básicos estão relacionados abaixo:
INTEIRO: qualquer número inteiro, negativo, nulo ou positivo. Ex: -5, 0, 235.
REAL: qualquer número real, negativo, nulo ou positivo. Ex: -5, 0, 30.5, 40.
STRING: qualquer conjunto de caracteres alfanuméricos. Ex: “str”, “abc”,“texto123”.
Todas as variáveis devem ser declaradas e inicializadas segundo a sintaxe representada
na Figura 10.
Figura 10 - Sintaxe de declaração de variável
Fonte: O autor
São exemplos de declaração e inicialização de variáveis:
inteiro:Int1=0;
real:R1=1.5;
string:Str=”str”;
É importante ressaltar que o Robotec não distingue letras maiúsculas ou minúsculas
sendo assim, diferente do JAVA, não importa se o código for digitado em caixa-alta ou caixa-
baixa.
3.1.2.2 Interpretação do código
Basicamente o Módulo Interpretador efetua a identificação dos comandos em G-
Portugol digitados pelo usuário e os converte em comandos da linguagem Java. Contudo, para
que erros de sintaxe fossem evitados foi necessário programar uma verificação de todo o
código digitado pelo usuário. Tal atividade se realiza através do clique do botão “Verificar” e,
assim inicia-se uma análise semântica e sintática dos comandos presentes no algoritmo,
evitando possíveis erros na tradução do algoritmo para a linguagem Java. Após a verificação,

40. 39
se nenhum erro for encontrado, o Robotec permite que o botão “Rodar” seja clicado. Caso
contrário, apresenta qual foi o erro e em qual linha foi encontrado.
O botão “Rodar” é o responsável pela tradução e execução do algoritmo, pois efetua
leitura de todo o código e faz comparações buscando encontrar as palavras reservadas da
linguagem.
No momento em que uma palavra é encontrada, um bloco de texto é separado do
código e, então, é feita sua tradução. O resultado é, por sua vez, adicionado a um arquivo
temporário o qual, ao término da tradução de todo o código, é executado pela máquina virtual
do Java.
3.1.3 Módulo matemático
Este módulo em específico utiliza de forma constante os cálculos da cinemática do
braço robótico AL5D. Sendo assim, através da aba “Álgebra” contida na interface do módulo
matemático, ilustrada na Figura 11, torna-se possível o controle adequado dos movimentos do
braço robótico para comandos, os quais exijam cálculos de álgebra vetorial, por exemplo. Na
versão 1.0 do software, é possível determinar as coordenadas exatas para as quais o efetuador
ou ponta da garra do braço deverá apontar, além de conter uma interface simples,
possibilitando desenhar círculos ou retas na área de trabalho do robô.

41. 40
Figura 11 – Inteface do módulo matemático
Fonte: O autor
Esta inteface possui três botões chamados “Mover”, onde cada um deles executa a
função de acordo com os valores descritos acima destes. Contudo, nem todos os movimentos
são possíveis devido à limitação física do robô utlizado. Motivo que gerou a implantaçao de
um método de verificação onde, além de cada movimento executado, ao ser pressionado
qualquer um dos botões, são enviados os valores atuais da posição de cada servo motor, e com
base nestes valores é possível, através da cinemática, detectar uma colisão ou uma posição
inalcansável.
3.1.4 Comunicação do braço robótico
A comunicação do braço robótico AL5D da Lynxmotion é dada por uma porta serial.
Esta porta é parte integrante da maioria dos computadores há mais de 20 anos. Embora muitos
dos novos computadores tenham abolido a porta serial completamente, colocando em seu
lugar conexões USB (Universal Serial Bus), alguns ainda utilizam a porta serial, como
algumas impressoras, PDAs, e Modems. As portas seriais dos computadores são do tipo
RS232, RS é uma abreviação de “Recommended Standard”, que relata uma padronização de

42. 41
uma interface comum para comunicação de dados entre equipamentos, criada no início dos
anos 60, por um comitê conhecido atualmente como “Electronic Industries Association”
(EIA).
A comunicação entre o software Robotec e o chip controlador do braço robótico é
feita por uma transmissão do tipo bit-serial, que inicia a transmissão com um bit de início e,
então, divide os comandos bit a bit e os transmite, sequencialmente, até o chip controlador do
braço robótico. Este chip, então, reorganiza os bits e compõem a informação original enviada,
a qual contém dados que identificam o servo-motor e o movimento a ser executado.
Para que a comunicação ocorra é necessário que a taxa de transferência da porta serial
seja definida em 115200, pois é o padrão do chip controlador presente no braço robótico
AL5D. Esta taxa de transferência refere-se à velocidade com que os dados são enviados
através de um canal, e é medido em transições elétricas por segundo.
Foi possível a movimentação do braço robótico através de valores angulares e, para
que fossem corretamente enviados estes valores para a interface serial, de forma que o robô
encontrasse a posição ideal para a qual devesse se mover, foi necessário efetuar uma
conversão.
Esta conversão de valores angulares encontrados nos cálculos da cinemática faz com que
os servos-motores do braço robótico entendam um ângulo específico, que foi efetuada da
seguinte maneira: primeiro encontrou-se os valores dos servos-motores em que a posição da
junta i estivesse no ângulo 0º, 90° e 180°. Após isso, o valor encontrado no servo-motor foi
dividido pelo ângulo correspondente. Logo, para cada uma das três situações foi acrescentada,
na lógica do software, uma verificação em que, no caso de proximidade do ângulo destino, o
valor para a posição do servo-motor mais próximo fosse calculado minimizando a margem de
erro, isto é, efetuado automaticamente para cada uma das juntas durante a movimentação do
braço robótico.
3.2 PROJETO DO SISTEMA
O projeto do software consistiu no desenvolvimento de cinco etapas que estão
relacionadas abaixo:
1° Etapa - Construção da interface do sistema, que consistiu em elaborar e desenvolver
toda a interface do software. No capítulo 3.5 encontra-se uma descrição das telas do
software.

43. 42
2° Etapa - Construção do controlador do braço robótico, que consistiu em fazer com
que o braço robótico se movesse através da interface de controle.
3° Etapa - Construção do módulo de cinemática direta e inversa, que consistiu em
desenvolver todos os cálculos para que fosse possível mover o braço robótico de uma
maneira mais conveniente e, alcançar o objetivo de auxiliar no ensino de conceitos de
álgebra.
4° Etapa - Construção do interpretador de comandos, a qual consistiu em desenvolver
o interpretador de comandos do software e fazer com que os algoritmos descritos
fossem traduzidos e executados, movendo o braço robótico.
5° Etapa - Validação do sistema através de testes com os usuários, que consistiu em
aplicar o software em um grupo de acadêmicos do curso de bacharelado em sistemas
de informação do campus da Universidade do Estado de Santa Catarina em São Bento
do Sul – CEPLAN, e verificar o funcionamento e utilidade do software.
3.3 REQUISITOS DO PROTÓTIPO
A especificação de requisitos visa obter produtos de software de melhor qualidade que
satisfaçam às necessidades dos usuários dentro de prazo e orçamento adequados.
Foram, então, definidos três passos para especificar os requisitos do protótipo, que
são:
1- Descoberta dos requisitos – por meio de documentos, pesquisas e entrevistas;
2- Análise dos requisitos identificados com refinamento e detalhamento dos mesmos;
3- Modelagem e Validação dos requisitos verificando sua consistência.
Após a descoberta, a análise, o refinamento e o detalhamento dos requisitos tornou-se
possível efetuar a modelagem e a validação dos mesmos, obtendo desta forma requisitos bem
definidos e entendíveis por todos os intervenientes do projeto que são os stakeholders ou

44. 43
participantes do projeto.
Os requisitos foram classificados em funcionais e não-funcionais, onde nos requisitos
funcionais descrevem as funcionalidades do sistema desejadas pelos clientes, ou seja, O QUE
se espera que o software faça. Já os requisitos não-funcionais descrevem as qualidades e
restrições globais do sistema relacionados com manutenção, uso, desempenho, custo,
interface, etc.
Os requisitos definidos para o protótipo estão relacionados na Tabela 6.
Tabela 6 - Tabela de classificação de requisitos
Tipo Requisito
Requisito funcional O sistema deve possibilitar a criação, edição, exclusão,
salvamento e execução de algoritmos escritos na forma
suportada pelo sistema.
Requisito funcional O sistema deve mover o braço robótico AL5D fabricado
pela Lynxmotion.
Requisito não-funcional O Sistema deve possuir uma interface intuitiva que
facilite sua operação.
Requisito não-funcional O Software deve ser operacionalizado no sistema
operacional Windows.
Requisito não-funcional O computador utilizado deve possuir no mínimo 512 MB
de memória RAM.
Requisito não-funcional O tempo de resposta do sistema não deve ultrapassar 10
segundos;
Fonte: O autor
Após a obtenção dos requisitos foi realizada a criação de oito diagramas atendendo às
visões da arquitetura de software, ilustrada na Figura 12. Os diagramas exibidos abaixo têm
por objetivo tornar a aplicação melhor entendida para que alterações e novas funcionalidades
fossem facilmente implementadas.

45. 44
Figura 12 - Visões da arquitetura de software
Fonte: O autor
3.3.1 Visões da arquitetura de software
A arquitetura de software compreende, como ilustrado na Figura 12, a visão de caso
de uso, a visão lógica, a visão de processos, a visão de implementação e a visão de
implantação. Abaixo temos uma relação dos diagramas que completam as visões da
arquitetura de software.
O diagrama de classes é o diagrama mais importante da UML, pois através dele
podem-se desenvolver os demais diagramas. Segundo Fowler (2000, p. 57), “Um diagrama de
classes descreve os tipos de objetos no sistema e os vários tipos de relacionamentos estáticos
que existem entre eles”. No diagrama de classes, as classes representam as propriedades e o
comportamento de um conjunto de objetos em um sistema e, consequentemente, os
relacionamentos destes objetos. O diagrama de Classes do sistema desenvolvido encontrasse
no apêndice A.
Nas Figuras 13 e 14, temos o diagrama de casos de uso e o diagrama de sequência.
Figura 13 - Diagrama de Casos de uso
Fonte: O autor

46. 45
Abaixo segue a tabela de detalhamento do caso de uso:
Tabela 7 - Tabela de detalhamento do caso de uso
Interpretador
Descrição Verifica se o código digitado possui erros sintáticos ou
semânticos e gera o arquivo Java temporário.
Pré-condições Existir um código digitado na aba “Programa” do interpretador.
Fluxo principal 1. O usuário executa o interpretador, informando o código que
deve ser executado.
2. O interpretador executa as análises léxica, sintática e semântica
do código digitado.
3. O interpretador gera código Java no arquivo temporário.
Fluxo alternativo Não há.
Fluxo de exceção No passo 2, caso o interpretador encontre algum erro no código
digitado:
1. O interpretador informa o erro ao usuário para que o mesmo
possa corrigi-lo.
2. O interpretador encerra o processo de tradução.
Pós-condições É gerado um arquivo fonte Java temporário.
Fonte: O autor

47. 46
Figura 14 - Diagrama de Sequência
Fonte: O autor
O diagrama de casos de uso descreve a funcionalidade do sistema. Casos de uso e
cenários são considerados o ponto de partida e, também, de consolidação das outras visões.
Enquanto que o diagrama de sequência apresenta uma visão geral do processo de
interpretação com as principais classes de cada etapa.
Na Figura 15, temos o diagrama de comunicação, este diagrama mostra uma interação
dinâmica de um caso de uso organizada em torno de objetos, de maneira que são usados
números de sequência para evidenciar as sequências das mensagens. Este diagrama exibe
como ocorre a interação entre o usuário e o interpretador, onde o usuário tem a opção de
escolher entre, digitar um algoritmo para mover o braço robótico ou simplesmente movê-lo
através da interface de controle.

48. 47
Figura 15 - Diagrama de Comunicação
Fonte: O autor
Na Figura 16, temos o diagrama de estados, que relaciona os possíveis estados que os
objetos da classe podem ter e quais eventos causam as mudanças de estado. Este diagrama de
estados mostra o processo de intepretação do código fonte digitado pelo usuário e os estados
básicos deste processo.
Figura 16 - Diagrama de estados
Fonte: O autor
Na Figura 17, temos o diagrama de componentes que exibe as dependências entre os
principais componentes do software, inclusive componentes do código fonte.

49. 48
Figura 17 - Diagrama de Componentes
Fonte: O autor
Na Figura 18, temos o diagrama de implantação, que mostra os elementos da
configuração básica de funcionamento do sistema. Este diagrama modela o uso físico do
sistema, considerando os computadores, dispositivos e as interconexões.
Figura 18 - Diagrama de Implantação
Fonte: O autor
3.4 ESTRUTURA DO SISTEMA PROPOSTO
Antes da construção do software proposto, foi preciso definir como seria sua estrutura
de funcionamento, e isto levou ao estudo de compiladores, interpretadores e máquinas
virtuais. Basicamente, segundo DAVID, MARCIO F. (2007) um compilador é um conversor
capaz de traduzir um código fonte em um código binário reconhecido pelos computadores. O
código gerado por um compilador é incompreensível para o ser humano, mas pode ser lido e

50. 49
executado pelos computadores.
De uma forma simples, após o algoritmo ter sido digitado pelo programador, o
compilador verifica se este algoritmo não contém nenhum erro e o traduz para uma sequência
de zeros e uns (código binário), que o computador (Sistema Operacional) é capaz de entender.
Após isso, o programa final gerado está pronto para ser executado. Então resumidamente, o
processo de compilação seria o seguinte: primeiro o programador escreve o código fonte e
executa o compilador, assim o compilador procura por erros de gramática e de semântica e
gera um arquivo executável (binário), após, o programador executa o código binário e o testa,
tais procedimentos são refeitos até que o programa esteja completo e pronto para a utilização
do usuário final.
Já um interpretador é diferente de um compilador por não gerar nenhum código
binário. O que ocorre em um interpretador é o seguinte: O programador escreve o código
fonte, então, o interpretador irá ler este código procurando por eventuais erros e, ao mesmo
tempo, já o executa e mostra para o usuário o resultado. Em resumo, os interpretadores não
geram um código binário e o algoritmo desenvolvido para ser executado é interpretado
novamente a cada nova instância.
Seguindo o estudo, encontra-se a máquina virtual, é algo que fica entre um compilador
e um interpretador pois, no caso das máquinas virtuais, o programador escreve um código
fonte e executa um programa (compilador), que irá traduzir o texto redigido pelo programador
(código fonte), em um código binário; assim como acontece com os compiladores
tradicionais, no caso da Maquina Virtual Java, o “bytecode”. Mas a grande diferença neste
caso, é que o código binário gerado não pode ser executado diretamente pelo computador,
embora ele seja binário, ele é incompreensível para o computador. Para que o computador
possa executar este código, é necessária uma máquina virtual. A máquina virtual traduz o
código binário gerado pelo compilador em um código binário que o computador (Sistema
Operacional) possa entender.
3.5 TELAS DO PROTÓTIPO
A seguir são apresentadas as principais telas do sistema e uma breve descrição de suas
funcionalidades.
A Figura 19 ilustra a janela principal do Sistema e os sub-menus do menu “Arquivos”

51. 50
Figura 19 - Interface principal, menu "Aquivos"
Fonte: O autor
A seguir, é descrita a funcionalidade dos seguintes sub-menus “Novo”, “Carregar”,
“Salvar”, “Apagar” e “Sair”, onde o sub-menu “Novo” abre, na aba “Programa”, um código
base para o desenvolvimento dos algoritmos. O sub-menu “Carregar” abre uma janela de
seleção, na qual é possível escolher e carregar na aba “Programa” um arquivo de código fonte
desenvolvido e salvo através do software e, que contenha a extensão de arquivo “.bot”. O sub-
menu “Salvar” abre uma janela que efetua o salvamento em disco do código fonte digitado
pelo usuário na aba “Programa”. O sub-menu “Apagar” abre uma janela de seleção, na qual é
possível escolher e excluir arquivos salvos pelo software e o sub-menu “Sair” fecha a
aplicação.
A figura acima ilustra ainda, a aba “Serial”, que tem por objetivo estabelecer a
conexão entre o software e o braço robótico, através da seleção da porta “COM“ de
comunicação. O software exibe uma lista de portas “COM” disponíveis no computador em
que está sendo executado. Também, encontra-se presente nesta aba, um campo de texto para
seleção da taxa de transferência da porta, o botão “Conectar” que efetua a conexão, o botão
“Desconectar” que aborta a conexão e o botão “Limpar” que efetua a limpeza da área de texto
que exibe o histórico de conexões efetuadas e abortadas.

52. 51
Figura 20 - Interface principal, menu "Edit"
Fonte: O autor
A Figura 20 ilustra a janela principal do Sistema e os sub-menus do menu “Edit”. Este
menu é composto pelos sub-menus “Copiar”, “Apagar”, e “Procurar”.
A funcionalidade dos sub-menus citados acima estão descritas a seguir:
 Copiar – Copia todo o texto selecionado na aba “Programa” para a área de
transferência do sistema operacional Windows o “clipboard”;
 Apagar – Apaga o texto selecionado na aba “Programa”;
 Procurar – Efetua busca por uma palavra ou frase por todo o texto digitado na aba
“Programa”.

53. 52
Figura 21 - Interface principal, menu "Help"
Fonte: O autor
A Figura 21 ilustra a janela principal do Sistema e os sub-menus do menu “Help”.
Este menu é composto pelo sub-menu “Créditos”, que exibe o nome dos contribuintes do
projeto do sistema e pelo sub-menu ”Ajuda”, que exibe o manual de operação do sistema para
o usuário.

54. 53
Figura 22 - Interface principal, aba Controle
Fonte: O autor
A Figura 22 ilustra a janela principal do Sistema e a aba “Controle”. Esta aba, como
descrita anteriormente, possui controles quem movem individualmente os servo-motores, e
ainda possui o botão “Reiniciar”, que é responsável pelo posicionamento inicial do braço
robótico para que os movimentos possam ser executados de forma correta.

55. 54
Figura 23 - Interface principal, aba Álgebra
Fonte: O autor
A Figura 23 ilustra a janela principal do Sistema e a aba “Álgebra”. Esta aba, como
descrita anteriormente, tem a finalidade de mover o braço robótico para coordenadas
específicas além de, em conjunto com a cinemática inversa implantada no sistema, mover o
braço em retas, diagonais e círculos, através dos botões “Mover” presentes nesta aba.

56. 55
Figura 24 - Interface principal, aba Programa
Fonte: O autor
A Figura 24 ilustra a janela principal do Sistema e a aba “Programa”. Esta aba, como
descrita anteriormente, tem como objetivo propiciar que um algoritmo seja criado, editado e
apagado. Possui, também, o botão “Verificar”, que efetua a análise sintática e semântica do
código digitado e libera para clique o botão “Rodar”, o qual executa o algoritmo, movendo o
braço robótico em conformidade com os comandos descritos no algoritmo.
3.6 FERRAMENTAS COMPUTACIONAIS UTILIZADAS
O software Robotec foi desenvolvido utilizando apenas a IDE Eclipse de
desenvolvimento Java da Eclipse Foundation e, consequentemente, a máquina virtual Java da
SUN Microsystems/Oracle.

57. 56
3.6.1 O Java
O Java teve seu início no ano 1991, segundo Deitel e Deitel (2003, p. 59), em um
projeto interno de pesquisa corporativa, financiado pela Sun Microsystems, que apostava no
futuro do mercado de dispositivos eletrônicos inteligentes.
O conjunto de tecnologias que formam o Java é dividido em três plataformas:
a) Java Platform Micro Edition (Java ME): para o desenvolvimento aplicativos para
dispositivos móveis e sistemas embarcados;
b) Java Platform Standard Edition (Java SE): para o desenvolvimento de aplicativos
para computadores desktop;
c) Java Platform Enterprise Edition (Java EE): para o desenvolvimento de aplicativos
empresariais de grande porte.
Apesar da linguagem Java estar disponível gratuitamente, ela em si não possui
nenhuma facilidade para edição de programas. Para editar programas de forma mais produtiva
é necessário fazer uso de alguma IDE (Integrated Development Environment).

58. 57
4 ANÁLISE DOS RESULTADOS
O objetivo deste capítulo é apresentar o resultado dos testes realizados com o protótipo
computacional descrito no capítulo anterior.
Os testes consistiram na simulação e aplicação do projeto com um grupo de três
acadêmicos do curso de Bacharelado em Sistema de Informação, do Centro de Educação do
Planalto Norte da Universidade do estado de Santa Catarina, no intuito de comprovar a
validade do modelo proposto e apresentar as limitações do modelo.
Após os testes, os resultados foram analisados e foi, então, constatado que o modelo
proposto foi desenvolvido com total sucesso e sua aplicação, mediante acadêmicos, foi
excelente.
4.1 DESEMPENHO
Para testar o desempenho do protótipo desenvolvido neste trabalho, foram simulados
diversos tamanhos de algoritmos e os testes foram submetidos a computadores com
configurações de processadores e memórias distintas.
Constatou-se que, pelo fato do sistema rodar com base em uma máquina virtual Java,
não há uma resposta imediata ao usuário. Porém, ainda está em conformidade com os
requisitos não-funcionais relatados anteriormente.
4.2 LIMITAÇÕES DO SISTEMA
A limitação do sistema desenvolvido consiste na aplicabilidade restrita a
computadores que possuam interface de comunicação serial no padrão RS232, para que o
braço robótico especificado comunique-se, e como relatado anteriormente, esta interface de
conexão não está contida na maioria dos novos computadores desktop produzidos, assim
como notebooks. Como solução para este problema sugere-se a utilização de um cabo
conversor USB para Serial. Existem novas versões do braço robótico com interface USB, no
entanto seria necessário modificar o sistema desenvolvido para comunicar-se com o braço
através desta interface de comunicação, substituindo a interface serial.

59. 58
5 CONSIDERAÇÕES FINAIS
Neste trabalho foi proposta uma ferramenta computacional capaz de mover um braço
robótico e que possibilitasse o ensino da lógica de programação, assim como conceitos de
álgebra vetorial e cinemática básica, através de algoritmos baseados em pseudocódigo
Portugol. O protótipo foi construído utilizando a programação orientada a objetos e o software
foi testado com sucesso, utilizando um grupo de três acadêmicos. A hipótese geral deste
trabalho foi plenamente comprovada, pois foi possível criar um modelo computacional capaz
de mover um braço robótico, através de comandos em uma extensão do Portugol e, servir de
auxílio no ensino de conceitos de álgebra e cinemática.
Pode-se concluir, também, que o trabalho proposto representa uma contribuição ao
curso de Sistemas de Informação, uma vez que ele se mostrou eficaz na solução do problema.
Como sugestão de trabalhos futuros, recomenda-se aumentar o número de comandos
reconhecidos no interpretador, adicionar sensores, e construir uma interface de visualização
tridimensional do braço robótico. Esta interface simularia a execução do algoritmo para que
não se fizesse necessária a presença do robô, permitindo que os algoritmos pudessem ser
testados e executados em qualquer ambiente operacional. Ainda como trabalhos futuros
sugere-se programar uma interface Web para acesso remoto aos estudantes com agendamento
de horários para movimentação do braço robótico remotamente com o auxilio de uma câmera
IP.

60. 59
REFERÊNCIAS
MODRO, Nilson Ribeiro; SILVA, Antônio Carlos Tamanini; MODRO , Nelcimar Ribeiro;
MODRO , NEILSON Luiz Ribeiro. ROBOTEC: Uma abordagem lúdica para o ensino de
lógica de programação em Engenharia. VI simpósio de engenharia de produção do
nordeste. 28 a 30/06/2011. UFCG, Campina Grande-PB.
SILVA, Antônio Carlos Tamanini; MODRO, Nilson Ribeiro; ARNOLD, Agnaldo Vanderlei;
RITZMANN, Magno Ronan; SILVA, Guilherme Augusto. ROBOTEC módulo
compilador: uma abordagem lúdica para o ensino de lógica de programação em
engenharia. XVIII simpósio de engenharia de produção, 07 a 09/11/2011. UNESP, Bauru-
SP.
BARBOSA, Marcelo R. G.; SILVA, Felipe A.; OLIVEIRA, Victor M. de A.; FELTRIM1,
Valéria D.; MIRISOLA, Luiz G. B.; GONÇALVES, Paulo C.; RAMOS , Josué J. G.; ALVES
,Lucas T. Implementação de Compilador e Ambiente de Programação Icônica para a
Linguagem Logo em um Ambiente de Robótica Pedagógica de Baixo Custo.
BIANCHI, R.A.C.; MOREIRA JR., B.S.; FERRAZ, F.C. & RILLO, A.H.R.C. Operation of
a robotic manipulator through the world wide web. Revista Pesquisa e Tecnologia.
Faculdade de Engenharia Industrial da Fundação de Ciências Aplicadas, n. 17, fevereiro 1998.
P. 22-27.
CORROCHANO, E.B. & KÄHLER, D. Kinematics of Robot Manipulators in the Motor
Algebra Disponível em: <http://www.ks.informatik.uni-
kiel.de/~vision/doc/Publications/geocom/bayro_kaehler.pdf>. Acesso em: <10/Fev/2011>
DASGUPTA, S.; PAPADIMITRIOU, C.H. & VAZIRANI, U.V. Algoritmos. São Paulo:
McGraw-Hill, 2009. 320 pag. : ISBN 9788577260324.
DEITEL, H. M.; DEITEL, P. J. Java: Como Programar. Trad. Edson Furnankiewicz. 3a
ed.
Porto Alegre: Bookman. 2001.

61. 60
GUIMARÃES, A.M. & LAGES, N.A.C.. Algorítmos e estruturas de dados. Rio de Janeiro:
Livros Técnicos e Científicos, 1985. 216 pag. ISBN 8521603789.
LIVESEY, C. Theory end Methods. Practical and Theoretical Research Considerations.
Disponível em: <www.sociology.org.uk>. Acesso em: 15/10/2010.
MANZANO, J.A.N.G & OLIVEIRA, J.F. Algoritmos: lógica para desenvolvimento de
programação de computadores. 12. Edição. São Paulo: Livros Erica, 2002. 236 pag. ISBN
857194718X.
NOF, S.Y. Handbook of Industrial Robotics. 2a Ed. USA. 1999.
PAZOS, F. Automação de sistemas e robótica. Axcel Books. Rio de Janeiro, 2002.
RIBEIRO, L.R. & MIZUKAMI, M.G.N. A PBL na Universidade de Newcastle: Um Modelo
para o Ensino de Engenharia no Brasil. Olhar de Professor. Universidade Ponta Grossa.
Departamento de Métodos e Técnicas de Ensino. v.7, n.1, p.133-147, 2004. Ed. UEPG.
Disponível em:
http://www.revistas.uepg.br/index.php?journal=olhardeprofessor&page=article&op=viewArti
cle&path[]=686. Acesso em: 31/07/2012.
ATTROT, Wesley; AYROSA, Pedro Paulo da S. Aplicações da Robótica no Ensino de
Ciência da Computação, 2002.
Tecnologia robótica aplicada no aprimoramento da educação técnica no Brasil.
Disponível em: http://www.xbot.com.br/tecnologia-robotica-na-educacao-tecnica/ Acesso em:
31/07/2012.
DAVID, MARCIO F. Iniciando no mundo da programação. 2007. Disponível em:
http://www.hardware.com.br/dicas/iniciando-mundo-programacao.html. Acesso em:
31/07/2012.

62. 61
SIMÕES, A.S. & RICCHETTI, P.F. Projeto e Implementação de um Braço Robótico de
Baixo Custo: uma Plataforma Multidisciplinar Para Motivação do Trabalho em Grupo.
Faculdades Associadas de São Paulo (FASP). Cobenge 2003.
QASSEM, Mohammed Abu; ABUHADROUS, Iyad; ELAYDI, Hatem, “Modeling and
Simulation of 5 DOF Educational Robot Arm”, The 2nd IEEE International Conference on
Advanced Computer Control, Shenyang, 20. Dec. 2009.
WIRTH, N (1976) Algorithms + Data Structures = Programs. Prentice-Hall.
SCHILLING, Robert Jr. Fundamentals of Robotics Analysis and Control.
Englewood Cliffs Prentice Hall. Cop, 1990;
SPONG, M. W e VIDYASAGAR, M. Robot Dynamics and Control. John Wiley &
Sons, New York, 1989;
SALIBA, Walter Luiz Caram. Técnicas de programação: uma abordagem estruturada.
São Paulo : Markon, 1992. 141 p.
FOWLER, Martin.; SCOTT Kendal. UML essencial: um breve guia para a linguagem –
padrão de modelagem de objetos. 169 p. 2. ed. – Porto Alegre: Bookman, 2000.
KAY, Jennifer.: Introduction to Homogeneous Transformations & Robot
Kinematics. Rowan University Computer Science Department. January 2005.

63. 62
GLOSSÁRIO
Interface Ferramenta ou ambiente por onde o usuário interage com um
sistema ou dispositivo;
Sistema Operacional Sistema que gerencia os dispositivos dos equipamentos e
permitem que aplicativos possam ser executados;
Software Parte lógica de um equipamento. Ex.: Sistema Operacional,
Aplicativos, etc.

64. 63
APÊNDICE A – Diagrama de classes do sistema

65. 64
APÊNDICE B – Manual de operação do software ROBOTEC
Manual de Operação
ROBOTEC
Versão 1.0
Novembro 2012

66. Manual de operação ROBOTEC
ROBOTEC é um controlador do braço robótico AL5D(Lynxmotion) e editor de
algoritmos em Português. Tem por objetivo auxiliar o aprendizado do aluno iniciante em
programação através da execução e visualização das etapas de um algoritmo. Com esse
interpretador, os alunos poderão implementar seus próprios algoritmos que por sua vez
movimentam um braço robótico, e através dessa animação torna-se fácil compreender, de
forma rápida e dinâmica, como as estruturas por eles desenvolvidas se comportam.
Com o intuito de difundir este novo sistema para a comunidade acadêmica,
informamos que o interpretador ROBOTEC encontra-se disponibilizado gratuitamente,
levando-se em consideração o leftright, ou seja, o sistema possui código aberto, permitindo
aos interessados o desenvolvimento de novas funcionalidades, desde que mantida a filosofia
inicial do mesmo e mencionadas ás autorias.
Desenvolvido por:
Antônio Carlos Tamanini;
Magno Ronan Ritzmann;
Nilson Ribeiro Modro.
Versão 1.0
Novembro 2012

67. Sumário
1. INTRODUÇÃO ........................................................................................................ 3
2. ESTRUTURA DO PROGRAMA............................................................................. 4
3. PALAVRAS RESERVADAS .................................................................................. 5
4. PONTUAÇÃO .......................................................................................................... 6
5. MAIÚSCULAS E MINÚSCULAS .......................................................................... 7
6. TIPOS DE DADOS................................................................................................... 8
7. DECLARAÇÃO E INICIALIZAÇÃO DE VARIÁVEIS ........................................ 9
8. FLUXO DE SAÍDA................................................................................................ 10
9. OPERADORES....................................................................................................... 12
10. COMANDO SE................................................................................................... 13
11. COMANDOS DE REPETIÇÃO......................................................................... 14
12. FUNCIONALIDADES DAS ABAS................................................................... 16
13. PRIMEIROS PASSOS ........................................................................................ 22

68. 3
1. INTRODUÇÃO
A maior dificuldade na concepção e no entendimento de algoritmos esta em como
entender as estruturas dinâmicas das possíveis execuções do algoritmo a partir de sua
estrutura estática. A linguagem definida no ROBOTEC visa auxiliar o processo de
aprendizagem do aluno iniciante em programação, integrando os aspectos dinâmicos e
estáticos em uma só ferramenta, permitindo ao aluno escrever seus programas em uma
derivação do “Portugol” - pseudo-linguagem de programação, executando e visualizando,
através da movimentação do braço robótico AL5D da Lynxmotion, o comportamento ativo do
seu algoritmo. O ROBOTEC aborda o mínimo de blocos básicos (de dados e controle)
necessários para o aprendizado de algoritmos, os quais se encontram descritos nos demais
itens deste Help.

69. 4
2. ESTRUTURA DO PROGRAMA
Todo programa ROBOTEC inicia-se com a palavra reservada programa seguida do nome do
programa, que obedece as normas de nomenclatura de identificadores. A seguir, são feitas as
declarações de variáveis, caso existam, conforme o capítulo 7 deste manual e, posteriormente,
é iniciado o bloco de comandos com a palavra reservada movimentos e inicio, encerrando-se o
programa com a palavra-chave fim.
programa <nome do programa>;
inicio_var
<declaração de variáveis> <opcional>;
fim_var
movimentos
inicio
<sequência de comandos>
fim
Um exemplo de programa é:
programa exemplo_01;
inicio_var
inteiro:cont1=100;
inteiro:cont2=150;
string:str="valor da minha str";
fim_var
movimentos
inicio
para(cont1=100;cont1<150;cont1++) faca//comentario1
adicionar_movimento(2,cont1,75);
fim_para
fim

70. 5
3. PALAVRAS RESERVADAS
Palavras reservadas são palavras-chave da linguagem, não podendo as mesmas serem
atribuídas a nenhum identificador (nome do programa e das variáveis definidos pelo usuário)
pertencente ao programa. Por exemplo, não podemos ter uma variável chamada para.
As palavras-chave no ROBOTEC são:
programa, movimentos, inicio_var, fim_var, string, real, inteiro, se, entao, senao, fim_se para,
fim_para, faca, enquanto, fim_enquanto, inicio, fim, adicionar_movimento, abre_garra, fecha_garra,
gira_base, move_ombro, move_cotovelo, move_pulso, gira_pulso, imprima.
As regras para nomenclatura dos identificadores encontram-se no capitulo 7.

71. 6
4. PONTUAÇÃO
Um sinal de pontuação é um tipo de palavra-chave abreviada. É um símbolo composto
por um ou dois caracteres, que tem um significado especial para o interpretador. O conjunto
completo de sinais da linguagem inclui os seguintes símbolos:
// ; , ( )
O sinal “;” encerra uma instrução, exceto nos casos em que a mesma possua delimitadores,
como no comando para. Esse sinal informa ao interpretador que ocorreu o fim de uma
instrução. Desse modo, podemos ter mais de uma instrução na mesma linha ou ter uma única
instrução em mais de uma linha. O símbolo // deve ser inserido para especificar um
comentário. Comentários em programas são mensagens que só serão vistas pelo programador,
sendo completamente ignoradas pelo interpretador. São utilizados visando dar maior
compreensão ao algoritmo. O símbolo // permite que apenas uma linha seja comentada por
vez, como segue o exemplo:
// Isto é um comentário
// Autor < seu nome>
programa meuPrimeiroPrograma;
inicio_var
string:helloworld="hello world"; //Declarando e inicializando a variável helloworld
fim_var
movimentos
inicio
imprima (helloworld);
fim
Os comentários podem ser inseridos em qualquer posição dentro do programa.

72. 7
5. MAIÚSCULAS E MINÚSCULAS
A linguagem definida no ROBOTEC não é sensível a caracteres maiúsculos e
minúsculos em nenhuma parte do código. Exemplo:
Robotec, robotec, ROBOTEC, RoBoTeC.
São variáveis iguais.
String - é uma palavra reservada como string.
Devido a isto, é recomendável utilizar um padrão para a nomenclatura dos
identificadores.

73. 8
6. TIPOS DE DADOS
O ROBOTEC fornece um conjunto de tipos de dados básico, onde cada um deles
serve a um propósito específico, definindo desse modo, o escopo dos valores que as variáveis
podem assumir no programa. Os tipos básicos implementados são:
inteiro - representando o conjunto dos números inteiros;
real - representando os pontos flutuantes;
string - representando um conjunto de um ou mais caracteres.

74. 9
7. DECLARAÇÃO E INICIALIZAÇÃO DE VARIÁVEIS
Todas as variáveis devem ser declaradas e iniciadas antes de serem usadas. Esta
declaração deve ser feita no início do programa. As variáveis possuem uma característica em
comum que é o tipo de dado associado. Isso é, além de escolhermos um nome apropriado para
uma variável, devemos também dizer que tipo de informação deve ser armazenada nela. Uma
declaração é definida por um tipo, seguido de : e o nome da variável daquele tipo e então o
símbolo = e o valor inicial da variável e para encerrar o ; , tal como o seguinte exemplo:
inteiro: num2 =2;
string: nome=”seu nome”;
As variáveis podem ser distribuídas entre declarações livremente. O exemplo acima
poderia ser igualmente escrito como:
Inteiro: num2=2; string: nome=”seu nome”;
Os nomes das variáveis podem ser compostos de letras e dígitos, sendo que o primeiro
caractere deve ser, obrigatoriamente, uma letra. Identificadores válidos: count, A1,a2.
Identificadores inválidos: 1A, 21 etc.
Para inicializar uma variável, ou atribuir um valor a ela, deve-se usar o símbolo =
como exemplo de atribuição num2=12; onde num2 é o nome da variável declarada e já
iniciada, = é o símbolo de atribuição e 12 é o valor a ela atribuído.
Quando interpretamos as instruções acima, os nomes das variáveis são substituídos
pelos valores associados na memória. É importante observar que o resultado da expressão do
lado direito de um comando de atribuição deve ser coerente com o tipo declarado para a
variável do lado esquerdo. Ao longo do programa é possível, através de atribuições, alterar os
valores dessas variáveis na memória.

75. 10
8. FLUXO DE SAÍDA
O ROBOTEC permite que um programa envie dados para o ambiente externo. Isto
pode ocorrer com o uso dos comandos imprima, adicionar_movimento, abre_garra, fecha_garra,
gira_base, move_ombro, move_cotovelo, move_pulso e gira_pulso. Não é possível entrar com
valores para o programa no momento de sua execução.
O comando imprima permite que sejam apresentados na saída padrão, normalmente o
monitor, mensagens e valores obtidos através da execução do programa, como mostra o
exemplo abaixo:
programa meuPrimeiroPrograma;
inicio_var
string:helloworld="olá Mundo...";
fim_var
movimentos
inicio
imprima (helloworld);
fim
a saída no monitor seria:
olá Mundo...
Os demais comandos enviam para a interface serial conectada ao braço robótico os valores
para que ocorra a movimentação do mesmo, abaixo seguem exemplos de aplicação destes
comandos:
adicionar_movimento(1,50,75); //Este comando envia para o braço robótico a informação de
que o servo-motor numero 1 deve se mover para a posição 50 com uma velocidade de 75
passos por minuto.
abre_garra(50); //Este comando efetua a abertura da garra do robô em 50%, esta porcentagem
pode ser modificada a critério do usuário.
fecha_garra(); //Este comando fecha a garra do robô, não há valores para este comando.
gira_base(128); // este comando efetua a movimentação do servo-motor conectado a base do
robô para a posição 128;
move_ombro(135); // este comando efetua a movimentação do servo-motor conectado ao

76. 11
ombro do robô para a posição 135;
move_cotovelo(120); // este comando efetua a movimentação do servo-motor conectado ao
cotovelo do robô para a posição 120;
move_pulso(140); // este comando efetua a movimentação do servo-motor conectado ao braço
do robô para a posição 140;
gira_pulso(90); // este comando efetua a movimentação do servo-motor conectado ao pulso do
robô para a posição 90;

77. 12
9. OPERADORES
O ROBOTEC utiliza também operadores que, são símbolos que executam várias
operações sobre os seus argumentos. O sinal de mais (+) é um operador. Em uma expressão,
ele soma dois valores:
a = b + c;
As variáveis a, b, c poderiam ser de quaisquer tipos numéricos de dados. Nesta
operação, b é acrescentado a c, sendo o resultado atribuído à variável a. O sinal de atribuição
= nessa expressão é também um operador, com a capacidade única de copiar um valor a sua
direita para a variável a sua esquerda. No ROBOTEC, existem operadores aritméticos,
relacionais e de atribuição, que estão demonstrados abaixo. Operações aritméticas:
adição (+)
subtração (-)
multiplicação (*)
divisão (/)
Essas operações devem ser efetuadas apenas com os operandos de um mesmo tipo.
Operadores relacionais:
maior (>); maior ou igual (>=); menor (<); menor ou igual (<=); igual (==);
diferente (!=)
Operadores de atribuição:
atribuição (=)
incremento (++)
decremento (--)
Os operadores de incremento e decremento são similares à atribuição, realizando operações de
adição e subtração, respectivamente. Dessa forma, uma variável é incrementada ou
decrementada em uma unidade. Portanto, essa variável deve ser do tipo inteiro. Em uma
atribuição, não podem ser usados operadores de incremento e decremento. Exemplos:
x = a; // x recebe o valor de a.
x--; // x é decrementado em 1.
x = x-1; // operação idêntica a anterior.
x++; // x é incrementado em 1.
x = x++ ou x = x--; // operações não suportadas.

78. 13
10. COMANDO SE
O comando utilizado para tomada de decisões no ROBOTEC é o se, que é
acompanhado, opcionalmente, pelo senao. Sua sintaxe é bastante simples, necessitando
acrescentar uma expressão que retorne um tipo lógico após a palavra se, a palavra reservada
entao e uma lista de comandos e terminar com a palavra reservada fim_se, caso o senao seja
utilizado, também haverá uma lista de comandos e o fim_se passa a ficar após os comandos do
senao. Por exemplo, para exibir o valor de uma variável “x” apenas se este valor for maior do
que 5, pode-se utilizar a seguinte instrução:
se (x > 5)entao
imprima(x);
senao
imprima (“x é menor q 5!”);
fim_se;
Os parênteses, as palavras então e fim_se, são obrigatórios.

79. 14
11. COMANDOS DE REPETIÇÃO
Na linguagem do ROBOTEC, podemos utilizar os comandos enquanto e para, para
aplicar instruções repetidamente. O comando enquanto tem sintaxe semelhante a do comando
se, bastando inserir alterar a palavra reservada após o fecha parênteses do comando para faca
e adicionar uma expressão que retorne um tipo lógico entre as palavras reservadas enquanto e
fim_enquanto e uma lista de comandos entre estas palavras, como mostra o exemplo:
i = 0;
enquanto( i < 10)faca
abre_garra(i);
i++;
fim_enquanto;
Nesse comando, a expressão relacional é avaliada antes da execução da instrução ou
bloco de comandos, ou seja, caso essa expressão seja falsa no início da execução do loop, os
comandos não serão executados.
O comando para tem a seguinte sintaxe, após a palavra reservada para são
adicionados a seguinte estrutura de verificação: abre parênteses <variável=valor> ; <variável
+ condição>; <variável + incremento ou decremento> e fecha parênteses após o fecha
parênteses é adicionada a palavra faca e após esta palavra os comandos a serem executados
seguidos de ; e terminando o bloco com fim_para, abaixo segue um exemplo do comando
para:
para (i=0; i < 10; i++)faca
abre_garra(i);
fim_para
Dentro dos parênteses, após a palavra-chave para, há três argumentos que controlam a
ação do loop. No primeiro argumento, há uma instrução que é executada uma única vez antes
do início do loop, atribuindo um valor a uma variável. A inicialização e a atribuição de valor
que compõem o primeiro e o terceiro argumento do comando para, respectivamente, fazem
referência a uma mesma variável. O segundo argumento é uma expressão relacional que a
instrução para testa no princípio do loop. O último argumento é executado ao final do loop,

80. 15
após a execução da instrução ou bloco de comandos, que devem estar entre as palavras faca e
fim_para.

81. 16
12. FUNCIONALIDADES DAS ABAS
O Robotec possui quatro abas e três menus, as abas suportam diferentes tipos de
controle do braço robótico exceto a aba Serial que define e conecta o braço robótico ao
software através de uma porta “COM” selecionada pelo usuário.
Figura 25 - Interface principal, aba Serial (menu Arquivos)
Fonte: O Autor
A figura 1 exibe a interface principal, aba Serial, que possui os campos Porta com e
Bauds e os botões Conectar, Desconectar e Limpar.
As funções para cada um dos campos e botões estão descritos na tabela 1 abaixo:
Tabela 8 - Funções dos campos da aba Serial
Fonte: O autor
Campo/ Botão Função
Porta com Definir a porta para conexão do braço robótico.
Bauds Definir a taxa de transmissão da porta selecionada.
Conectar Aplicar as configurações e estabelecer a conexão.
Desconectar Desconectar o braço robótico do software.
Limpar Limpar o histórico das conexões.
O menu arquivo presente na interface principal é responsável por carregar, excluir,

82. 17
criar e salvar um algoritmo na aba Programa, e encerrar o software.
Figura 26 - Interface principal, aba Serial (menu Edit)
Fonte: O Autor
O menu Edit ilustrado na figura 2 acima é responsável por copiar apagar ou procurar
uma frase ou letra no algoritmo digitado na aba Programa.
Para utilizar as funções de copiar ou apagar basta selecionar o texto que se deseja
apagar ou copiar e clicar no menu Edit e na função desejada.

83. 18
Figura 27 - Interface principal, aba Serial (menu Help)
Fonte: O Autor
O menu Help presente na interface principal é responsável por exibir os créditos de
desenvolvimento do software e o sub-menu ajuda exibe este manual.
Figura 28 - Interface principal aba Controle
Fonte: O Autor

84. 19
A aba ilustrada na figura 4 acima possui controles quem movem individualmente os
servo-motores, e possui também o botão “Reiniciar” que é responsável pelo posicionamento
inicial do braço robótico para que os movimentos possam ser executados de forma correta.
A descrição da relação entre as barras de rolagens e a movimentação do braço robótico
esta presente na tabela 2 abaixo:
Tabela 9 - Relação de movimentação entre a barra de rolagem e o braço robótico
Fonte: O autor
NOME SERVO-
MOTOR
FUNÇÃO RESTRIÇÃO
Motor 1 0 Responsável por enviar os bits referentes a
movimentação da base do braço robótico para
a porta serial, esta relacionada ao giro do
braço por completo.
0° a 180°
Motor 2 1 Responsável por enviar os bits referentes a
movimentação do ombro(Shoulder) do braço
robótico para a porta serial, atua de forma
vertical.
0° a 180°
Motor 3 2 Responsável por enviar os bits referentes a
movimentação do cotovelo(Elbow) do braço
robótico para a porta serial, atua de forma
vertical.
30° a 100°
Motor 4 3 Responsável por enviar os bits referentes a
movimentação do pulso(Wrist) do braço
robótico para a porta serial, atua de forma
vertical.
0° a 180°
Motor 5 4 Responsável por enviar os bits referentes ao
giro do pulso do braço robótico para a porta
serial, está relacionado ao giro do pulso.
0° a 180°
Motor 6 5 Responsável por enviar os bits referentes a
movimentação da garra(Grip) do braço
robótico para a porta serial, está relacionado
ao movimento de abrir e fechar a garra do
efetuador.
0° a 180°
Motor 7 - Disponível para futuras modificações no braço
robótico.
-
Motor 8 - Disponível para futuras modificações no braço
robótico.
-

85. 20
Velocidade - Define o intervalo de envio entre os bits de
saída do software.
-
Reiniciar 0,1,2,3,4,5 Envia para todos os servos-motores, os dados
para sua posição inicial.
-
Figura 29 – Interface principal aba Álgebra
Fonte: O Autor
A Figura 5 ilustra a janela principal do Sistema e a aba “Álgebra”, esta aba tem a
finalidade de mover o braço robótico para coordenadas específicas além de, em conjunto com
a cinemática inversa implantada no sistema, mover o braço em retas, diagonais e círculos,
através dos botões “Mover” presentes nesta aba.

86. 21
Figura 30 - Interface principal aba Programa
Fonte: O Autor
A Figura 6 ilustra a janela principal do Sistema e a aba “Programa”, esta aba tem
como objetivo propiciar que um algoritmo seja criado, editado e apagado, possui o botão
“Verificar”, que efetua a análise sintática e semântica do código digitado e libera para clique o
botão “Rodar”, que executa o algoritmo, movendo o braço robótico em conformidade com os
comandos descritos no algoritmo.

87. 22
13. PRIMEIROS PASSOS
Para executar seu primeiro algoritmo, ou mover o braço robótico através do software
pelas abas de controle ou álgebra, deve-se posicionar manualmente antes de ligar o braço
robótico de forma que todos os servo-motores fiquem na metade de sua movimentação total,
como ilustrado na figura 7 abaixo:
Figura 31 - Posição Inicial do braço robótico
Fonte: O autor
Após isto se pode ligar o braço robótico e iniciar o ROBOTEC, e na aba Serial
seleciona-se a porta de comunicação na qual o braço está conectado e então o botão conectar é
pressionado. A partir deste ponto pode-se ser usada qualquer uma das abas: Controle, Álgebra
ou Programa.
Sugere-se que ao efetuar a conexão do software com o braço robótico o botão reiniciar
presente na aba controle seja pressionado, evitando dessa forma problemas na movimentação.
IMPORTANTE: Devido à ausência de sensores os motores não possuem proteção e desta
forma podem ser danificados no caso de excesso de peso ou força contraria, evite que o braço
robótico colida com a mesa ou objetos, se isto ocorrer desligue-o imediatamente.