Your SlideShare is downloading. ×
Tcc magno ronan ritzmann
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Tcc magno ronan ritzmann

573
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
573
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
23
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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.