plataforma robótica didática baseada em arduino e raspberry...
TRANSCRIPT
Plataforma Robótica Didática Baseada em Arduino e
Raspberry Pi
Rafael Huang Cestari
Projeto de Graduação apresentado ao Curso de
Engenharia Mecânica da Escola Politécnica,
Universidade Federal do Rio de Janeiro, como
parte dos requisitos necessários à obtenção do
título de Engenheiro.
Orientador : Vitor Ferreira Romano, Dott. Ric.
Rio de Janeiro
Março de 2019
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Departamento de Engenharia Mecânica DEM/POLI/UFRJ
Plataforma Robótica Didática Baseada em Arduino e
Raspberry Pi
Rafael Huang Cestari
PROJETO DE GRADUAÇÃO SUBMETIDA AO CORPO DOCENTE DO CURSO DE
ENGENHARIA MECÂNICA DA ESCOLA POLITÉCNICA DA UNIVERSIDADE
FEDERAL DO RIO DE JANEIRO COMO PARTE DOS REQUISITOS NECESSÁRIOS
PARA A OBTENÇÃO DO GRAU DE ENGENHEIRO MECÂNICO.
Examinada por:
Prof. Vitor Ferreira Romano, Dott. Ric. (Orientador)
Prof. Armando Carlos de Pina Filho, D.Sc.
Prof. Fábio da Costa Figueiredo, D.Sc.
RIO DE JANEIRO, RJ – BRASIL
Março de 2019
i
Cestari, Rafael Huang
Plataforma Robótica Didática Baseada em Arduino e
Raspberry Pi/ Rafael Huang Cestari. – Rio de Janeiro:
UFRJ/ Escola Politécnica, 2019.
IX, 116 p.: il.; 29,7 cm.
Orientador: Vitor Ferreira Romano
Projeto de Graduação – UFRJ/ Escola Politécnica/
Curso de Engenharia Mecânica, 2019.
Referencias Bibliográficas: p. 67-68.
1. Introdução. 2. Plataforma de Comando Didática. 3.
Especificação da Plataforma. 4. Detalhamento do
Dispositivo Mecatrônico. 5. Detalhamento da Unidade de
Controle 6.Controle, Programação e Comunicação 7.
Testes com servomotores 8. Resultados e Conclusões I.
Romano, Vitor Ferreira. II. Universidade Federal do Rio
de Janeiro, Escola Politécnica, Curso de Engenharia
Mecânica. III. Plataforma Robótica Didática Baseada em
Arduino e Raspberry Pi
ii
Agradecimentos
Agradeço a meus pais, Pedro e Ângela, por todo o apoio, carinho, lições e incentivo que
me deram durante toda minha vida.
Agradeço a meus avós, Pedro e Iolanda, por estarem igualmente presentes em minha
vida, sempre me guiando e apoiando.
Agradeço à minha tia, Sibele, por ser uma grande amiga durante minha vida e uma guia
durante meu início na graduação.
Agradeço à minha tia avó, Aidê, por sempre me dar o incentivo necessário para seguir
em minha vida.
Agradeço ao professor Vitor Ferreira Romano pela paciência e atenção dada durante
as aulas e durante este projeto de graduação. Sua orientação e instrução foram
indispensável para a conclusão deste trabalho.
Agradeço a meus colegas de faculdade Bruno, Caio, Eduardo, Lucas, Pedro e Raphael
pelas boas experiências, horas de estudo e trabalho compartilhados durante a
graduação.
Agradeço também a todos os professores do Departamento de Engenharia Mecânica
da UFRJ por todas as lições, conhecimento e experiências das quais tive o prazer de
aprender, aqduirir e viver.
iii
Resumo do Projeto de Graduação apresentado à Escola Politécnica/ UFRJ como parte
dos requisitos necessários para a obtenção do grau de Engenheiro Mecânico.
Plataforma Robótica Didática Baseada em Arduino e Raspberry Pi
Rafael Huang Cestari
Março/2019
Orientador: Prof. Vitor Ferreira Romano
Curso: Engenharia Mecânica
A utilização de métodos de automação e robótica em diversas indústrias vem se
mostrando cada vez mais prevalecente, exibindo funções cada vez mais complexas e
diversificadas. Há um claro interesse na formação de profissionais capacitados para o
projeto e operação de dispositivos robóticos. Em função disso, há uma necessidade de
cursos, materiais e equipamentos didáticos para o ensino e capacitação de alunos de
engenharia nesta área. Foi elaborada uma plataforma robótica didática controlada por
uma unidade de comando composta por uma união das plataformas Raspberry Pi e
Arduino, bem como os códigos necessários para sua operação, para utilização pelo
Laboratório de Robótica da UFRJ (LabRob), principalmente durante as aulas de
Automação e Robótica (EEK557) e Laboratório de Engenharia Mecânica I - módulo
Robótica (EEK351). O objetivo deste projeto foi criar um equipamento para o
aprendizado de conhecimentos de mecatrônica e automação atualizado e de fácil
compreensão para alunos de engenharia da UFRJ, bem como propiciar uma unidade
de controle cujas funcionalidades permitam que o mesmo possa ser utilizado por
professores e alunos como uma base para projetos de diversas naturezas.
Palavras-chave: Robótica, Automação, Mecatrônica, Programação, Cálculo de
resistência, Eletrônica.
iv
Abstract of Undergraduate Project presented to POLI/UFRJ as partial fulfillment of the
requirements for the degree of Mechanical Engineer.
Didactic Robotics Platform Based on Arduino and Raspberry Pi
Rafael Huang Cestari
March/2019
Advisor: Prof. Vitor Ferreira Romano
Course: Mechanical Engineering
The use of automation and robotics methods in various industries has shown itself as
increasingly prevalent, exhibiting increasingly complex and diversified functions. There
is clear interest in the formation of professional capable of designing and operating
robotics devices. A didactic robotics platform controlled by a command unit consisting in
the union of the Raspberry Pi and Arduino platforms, as well as the necessary codes for
its operation, were devised for use by the Robotics Laboratory of the UFRJ (LabRob),
mainly during the Automation and Robotics (EEK557) and Mechanical Engineering
Laboratory I – Robotics module (EEK351) classes. This work sought to create a modern
and comprehensive equipment directed towards the learning of mechatronics and
automation knowledge for engineering students of the UFRJ, as well as provide a control
unit in which its functionalities allow it to be used by teachers and students alike as a
base for projects of various natures.
Keywords: Robotics, Automation Mechatronics, Programming, Resistance calculations,
Electronics.
v
Sumário
1. INTRODUÇÃO ............................................................................................................. 1
1.1. Aspectos Gerais .................................................................................................... 1
1.2. Plataformas e Conjuntos Didáticos ....................................................................... 2
1.2.1. Kits de Robótica Modelix ................................................................................ 3
1.2.2. Kit Edison ........................................................................................................ 3
1.2.3. Kits de Robótica Lego Mindstorm ................................................................... 4
1.2.4. Kits Arduino ..................................................................................................... 5
1.2.5. Kits Raspberry Pi ............................................................................................ 6
1.2.6. Mesa XY de Posicionamento – LabRob ......................................................... 7
1.3. Organização do Trabalho ...................................................................................... 9
2. PLATAFORMA DE COMANDO DIDÁTICA ............................................................... 10
2.1. Configurações de Unidades de Comando .......................................................... 10
2.2. Conceito da Plataforma ....................................................................................... 13
2.3. Componentes Principais da Plataforma .............................................................. 14
2.3.1. Arduino .......................................................................................................... 14
2.3.2. Shields e complementos ............................................................................... 15
2.3.3. Raspberry Pi ................................................................................................. 16
2.3.4. Mecanismo controlado .................................................................................. 17
3. ESPECIFICAÇÃO DA PLATAFORMA ...................................................................... 19
3.1. Unidade de controle ............................................................................................. 19
3.1.1. Raspberry Pi 3 .............................................................................................. 19
3.1.2. Arduino UNO ................................................................................................. 20
3.1.3. Interface ........................................................................................................ 20
3.2. Manipulador com dispositivo de escrita .............................................................. 20
3.2.1. Descrição do manipulador ............................................................................ 20
3.2.2. Descrição do dispositivo de escrita .............................................................. 22
4. DETALHAMENTO DO DISPOSITIVO MECATRÔNICO .......................................... 25
4.1. Finalidade de Uso ................................................................................................ 25
4.2. Parte Mecânica .................................................................................................... 25
4.3. Dispositivo de Escrita .......................................................................................... 26
4.4. Caracterização do Manipulador .......................................................................... 27
4.4.1. Parâmetros de Posicionamento.................................................................... 27
4.4.1. Definição dos valores dos parâmetros ......................................................... 30
4.4.3. Volume de Trabalho Limite ........................................................................... 30
vi
4.5. Componentes ....................................................................................................... 33
4.5.1. Polias ............................................................................................................. 33
4.5.2. Análise estrutural dos elos ............................................................................ 34
4.5.3. Caracteríticas dos elos ................................................................................. 40
4.5.4. Rolamentos ................................................................................................... 41
4.5.5. Árvores ......................................................................................................... 41
4.5.6. Dispositivo de escrita .................................................................................... 43
4.5.7. Mesa e pés niveladores ................................................................................ 46
5. DETALHAMENTO DA UNIDADE DE CONTROLE ................................................... 48
5.1. Parte Elétrica ....................................................................................................... 48
5.1.1. Demanda do circuito lógico .......................................................................... 48
5.1.2. Demanda do dispositivo................................................................................ 48
5.1.3. Pinos e circuito .............................................................................................. 49
6. CONTROLE, PROGRAMAÇÃO E COMUNICAÇÃO ................................................ 51
6.1. Interface de operação do Raspberry Pi .............................................................. 54
6.2. Bibliotecas de Phyton e Arduíno ......................................................................... 55
6.3. Código .................................................................................................................. 55
7. TESTES COM SERVOMOTORES ............................................................................ 56
7.1. Escopo ................................................................................................................. 56
7.2. Descrição da Bancada experimental .................................................................. 56
7.2.1. Servomotor Futaba S3302 ............................................................................ 58
7.2.2. Braço ............................................................................................................. 59
7.2.3. Recursos de leitura de dados ....................................................................... 59
7.3. Procedimento ....................................................................................................... 60
7.4. Resultados do teste ............................................................................................. 61
8. RESULTADOS E CONCLUSÕES ............................................................................. 64
8.1. Simulação de operação ....................................................................................... 64
8.2. Conclusões .......................................................................................................... 65
8.3 Sugestões de Desenvolvimentos Futuros ............................................................ 66
Referências Bibliográficas .............................................................................................. 67
ANEXOS ......................................................................................................................... 69
ANEXO 3A .................................................................................................................. 69
ANEXO 3B .................................................................................................................. 69
ANEXO 3C .................................................................................................................. 70
ANEXO 4A .................................................................................................................. 73
ANEXO 4B .................................................................................................................. 74
vii
Desenhos ................................................................................................................ 74
ANEXO 6A .................................................................................................................. 75
ANEXO 6B .................................................................................................................. 76
ANEXO 6C .................................................................................................................. 78
Código de operação do dispositivo ......................................................................... 78
Código de simulação ............................................................................................... 94
Output das simulações ............................................................................................. 110
Letra A (10 mm - 0 graus – (10,10)) ..................................................................... 110
Letra C (20mm – 10 graus – (15,15)) ................................................................... 112
viii
Nomenclatura
𝑥𝑖 Eixo na direção x do elo i.
𝑦𝑖 Eixo na direção y do elo i.
𝑧𝑖 Eixo na direção z do elo i.
𝑎𝑖 Distância entre os eixos 𝒛𝒊−𝟏e 𝒛𝒊 ao longo do eixo 𝒙𝒊.
𝛼𝑖 Ângulo entre os eixos 𝑧𝑖−1e 𝑧𝑖 ao longo do eixo 𝑥𝑖.
𝑑𝑖 Distância entre os eixos 𝑥𝑖−1e 𝑥𝑖 ao longo do eixo 𝑧𝑖−1.
𝜃𝑖 Ângulo entre os eixos 𝑥𝑖−1e 𝑥𝑖 ao longo do eixo 𝑧𝑖−1.
𝑃𝐿 Comprimento da correia.
𝐶𝐷 Distância entre os centros das polias.
𝑃𝐷 Diâmetro da polia maior.
𝑝𝑑 Diâmetro da polia menor.
𝑓 Flecha de deflexão.
𝐹 Carga pontual exercida.
𝑙 Comprimento.
𝐸 Módulo de elasticidade.
𝐼 Momento de Inércia.
𝑞 Carga distribuída.
𝑔 Aceleração da gravidade.
𝐴 Área da seção.
ix
𝜇 Massa específica.
�̅�𝑖 Posição do centroide do perfil do elo i ao longo do eixo y.
𝐴𝑠𝑖 Área da subseção i.
𝑑𝑠𝑖 Distância do centroide da subseção i em relação ao centroide de sua seção ao
longo do eixo y.
𝑀 Momento.
𝛾 Ângulo de deflexão.
1
1. INTRODUÇÃO
1.1. Aspectos Gerais
A utilização de métodos de automação e robótica em diversas indústrias vem se
mostrando cada vez mais prevalecente com funções cada vez mais complexas e
diversificadas. Tal tendência gera a necessidade de profissionais capacitados para o
projeto, aplicação e manipulação de sistemas automatizados no mercado de trabalho.
Para introduzir e formar indivíduos à esta área da indústria, plataformas didáticas foram
criadas para auxiliar o aprendizado e compreensão dos processos envolvidos em um
projeto de automação e robótica. De simples conjuntos de montagem para compreensão
de mecanismos e circuitos básicos até kits que disponibilizam placas de controle,
sensores e atuadores voltados para o aprendizado de programação e métodos de
entrada e saída, estas plataformas abrangem diversos níveis de complexidade para
indivíduos de diferentes idades e níveis de conhecimento. No âmbito da Engenharia
Mecânica, visa-se obter uma plataforma na qual os engenheiros possam ter contato com
todas as facetas de um sistema mecatrônico, isto é, o projeto mecânico, o
funcionamento de atuadores e sensores e a programação e lógica do sistema (Figura
1.1).
Figura 1.1: Fluxograma de projeto mecatrônico
2
Há um evidente interesse em criar uma plataforma de uso geral para automação e
robótica para fins didáticos. Visa-se obter uma base na qual futuros engenheiros possam
obter conhecimento e familiaridade com os princípios envolvidos no projeto de um
sistema robótico, e que a mesma seja utilizável não só como ferramenta de ensino, mas
como uma plataforma versátil e viável para uso em pesquisas ou ambientes
profissionais.
Atualmente, sistemas mecatrônicos como braços robóticos multifuncionais (funções de
movimentação, montagem, solda, etc.), máquinas de usinagem CNC, impressoras 3D
de nível profissional, elevadores automáticos e até sistemas de controle hidráulicos
utilizam de plataformas de controle de preço relativamente alto, funcionalidade limitada
às funções das maquinas às quais são destinadas, poucas opções de comunicação com
outros aparelhos ou baixa capacidade de modificação. Alguns modelos mais recentes,
como robôs industriais KUKA, possuem opções de comunicação e integração mais
avançada com outros dispositivos, mas apresentam um sistema de arquitetura e
programação fechadas.
Com essas questões em mente, intenta-se criar uma nova plataforma de custo mais
acessível e maior versatilidade, que permita um maior controle de suas funções e facilite
a realização de modificações e adaptações necessárias para seu uso em diferentes
aplicações ou sua integração com diversos sistemas. Deseja-se, ainda, que a
plataforma possa comunicar-se por diversos meios em função das crescentes
tendências de interligação de aparelhos da Indústria 4.0.
Neste trabalho desenvolveu-se as concepções de uma unidade de controle e dispositivo
mecatrônico para uma plataforma didática, bem como os códigos de programação
necessários para a operação da mesma, de forma a propiciar uma compreensão
facilitada dos sistemas e permitir que a plataforma possa ser adaptada para aplicações
reais diversas.
1.2. Plataformas e Conjuntos Didáticos
A seguir são descritos alguns produtos disponíveis no mercado para utilização em
atividades didáticas.
3
1.2.1. Kits de Robótica Modelix
A Modelix produz kits de robótica voltados para diversos níveis: do ensino infantil e
fundamental até ensino médio e superior inicial (Figura 1.2). Os kits infantis possuem
apenas um foco na montagem de sistemas mecânicos, ao passo que os kits de ensino
fundamental e superior fazem uso de sistemas eletrônicos com atuadores e sensores
para controle do projeto mecânico. Todos os kits fazem uso de peças e plataformas
mecânicas prontas e um software licenciado e próprio da Modelix que possui um sistema
de fluxograma para programação. Os kits também dispõem de aulas virtuais para
acompanhamento dos alunos com o material incluso. As placas de controle podem ser
utilizadas com alguns tipos de atuadores e sensores desde que estejam de acordo com
as especificações de voltagem e corrente, mas a estrutura de programação é limitada
ao software vendido pela empresa, tornando sua compreensão em um nível mais básico
e sua diversidade de aplicações mais limitada.
Figura 1.2: Ilustração de projetos possíveis com o Kit Modelix Ensino Médio.(MODELIX, 2018)
1.2.2. Kit Edison
O kit Edison inclui um robô programável de duas rodas e múltiplos sensores e atuadores,
incluindo sensores de som, linha, luz e infravermelho (Figura 1.3). A plataforma é voltada
para um ensino mais básico direcionado à introdução de programação de robôs para
alunos mais novos. Diversos meios e linguagens de programação são disponibilizades
4
pelo fabricante para controlar o robô, incluindo Scratch, Python e EdBlocks, um método
de programação por blocos. O robô pode ser alterado com kits adicionais
disponibilizados pelo fabricante ou até mesmo partes de Lego padrão, mas a
versatilidade e aplicação da plataforma fora de um ambiente de aprendizado são
limitadas.
Figura 1.3: Robô Edison.(WSKITS, 2018)
1.2.3. Kits de Robótica Lego Mindstorm
A plataforma LEGO Mindstorm possui grande popularidade, sendo, ainda, utilizada em
competições internacionais. Os kits utilizam um computador (referido como
Programmable Brick) (Figura 1.4) próprio para o controle de tarefas com partes LEGO
Technic e atuadores e s0ensores adaptados para seu uso com outras partes LEGO e o
computador. A plataforma passou por várias versões: Robotics Invention System, NXT,
NXT 2.0, e a mais recente, EV3. A programação na plataforma Mindstorm não é feita
por meio de código, mas por blocos de programação. Apesar disso, devido à natureza
de código aberto da plataforma, outras linguagens de programação podem ser
adaptadas para seu uso em conjunto com o sistema de blocos. Além disso, é possível
instalar um sistema operacional baseado em Debian (ev3dev) no próprio computador
de controle via cartão SD, permitindo uso direto de outras linguagens de programação
como Python, além de permitir comunicação sem fio com outros equipamentos. Existem,
5
ainda, bibliotecas e recursos distribuidos gratuitamente pela internet para facilitar a
utilização da plataforma. Embora esta plataforma possibilite uma melhor compreensão
e versatilidade da parte de programação, as peças mecânicas e eletrônicas específicas
da plataforma criam certas limitações para sua aplicação. Assim como os kits Modelix,
a plataforma Mindstorm também possui uma versão educacional com aulas virtuais para
acompanhamento dos alunos. Diversos cursos e tutoriais criados por educadores e
usuários da plataforma também estão disponíveis gratuitamente na internet.
Figura 1.4: Bloco programável da plataforma LEGO Mindstorms EV3.(LEGO, 2018)
1.2.4. Kits Arduino
Algumas lojas virtuais especializadas em artigos eletrônicos vendem kits educacionais
com base na plataforma Arduino (Figura 1.5), geralmente acompanhados de cursos e
tutoriais on-line. Diferente dos computadores da plataforma Mindstorms, as placas
Arduino são apenas controladores nos quais um programa escrito em um computador
em uma linguagem própria baseada em C/C++ é carregado para executar tarefas
simples. Entretanto, por ser uma plataforma de arquitetura e código abertos, ela possui
baixo custo e ampla disponibilidade de recursos de programação e integração com
outros sistemas e linguagens, tornando sua aplicação extremamente versátil. Além
disso, a utilização de Shields e placas de adaptação, também de arquitetura aberta,
expandem ainda mais o escopo de atuação da plataforma, permitindo uso de diversos
tipos de atuadores e sensores em diferentes configurações.
6
Figura 1.5: Kit didático Arduino (ROBOCORE, 2018).
1.2.5. Kits Raspberry Pi
O Raspberry Pi é um microcomputador que faz uso de um sistema operacional baseado
em Debian (Raspian) carregado em um cartão microSD. Por ser um computador, ele é
capaz de realizar cálculos e funções mais complexas e pesadas que as outras
plataformas mencionadas, mantendo, ainda, um preço competitivo. O Raspberry Pi
possui portas de input e output de uso geral (GPIO), permitindo que atuadores e
sensores possam ser utilizados de forma similar ao Arduino, porém com versatilidade
reduzida quando comparada à plataforma anterior. Devido a isto, há um enfoque maior
no desenvolvimento de softwares, projetos de automação doméstica e lazer. A
plataforma também pode contectar-se à internet via cabo Ethernet ou Wi-Fi, e
comunicar-se com dispositivos Bluetooth, funções altamente desejáveis para projetos
de internet das coisas (Internet of Things).
7
Figura 1.6: Kit básico Raspberry Pi (FILIPEFLOP, 2018).
Embora Kits contendo o mínimo necessário para o funcionamento desta platafoma
sejam vendidos por diversas lojas (Figura 1.5), os mesmos geralmente não possuem
nenhum material didático específico associado. Desta forma, o aprendizado por meio
desta fica limitado à manuais, tutoriais, guias ou aulas disponibilizadas por terceiros na
internet.
1.2.6. Mesa XY de Posicionamento – LabRob
Atualmente, o Laboratório de Robótica da UFRJ dispõe de uma bancada de testes para
aulas experimentais (Figuras 1.7 e 1.8). Ela consiste em uma mesa XY de dimensões
de 300x300mm com dois motores de passo de resolução de 1,8 graus por passo,
utilizando 2 fusos de esfera recirculante de 5mm de passo. A unidade é controlada por
um programa baseado na linguagem C em um computador Pentium e alimentada por
uma fonte de 13,8V à 10 A. Durante as aulas experimentais, a plataforma é utilizada
para dar aos alunos uma aproximação dos princípios de programação, trajetórias e
ordem de operações de um projeto mecâtrônico. Uma das motivações deste projeto é
permitir que a plataforma seja adaptada para substituir o atual programa de controle que
possui código fechado, prejudicando o entendimento do sistema como um todo pelos
alunos.
8
Figura 1.7: Mesa XY de posicionamento do LabRob
9
Figura 1.8: Desenho esquemático da mesa XY
1.3. Organização do Trabalho
O capítulo 1 trata-se da introdução do trabalho. No capítulo 2 discute-se os diferentes
tipos de configurações de unidade de comando e define-se o conceito para a plataforma
didática. No capítulo 3 são especificados os componentes fundamentais a serem
utilizados na plataforma, tanto na unidade de controle como no dispositivo associado.
No capítulo 4 detalham-se as peças e componentes dos mecanismos do dispositivo da
plataforma. No capítulo 5 discute-se os aspectos eletrônicos da plataforma. No capítulo
6 o funcionamento da plataforma e sua programação são detalhados. No capítulo 7
exibe-se o procedimento e resultados de testes realizados com os servomotores do
dispositivo da plataforma. No capítulo 8 exibem-se os resultados da simulação do
programa de controle e conclusões do trabalho.
10
2. PLATAFORMA DE COMANDO DIDÁTICA
2.1. Configurações de Unidades de Comando
Considerando os pontos expostos no item anterior, propõe-se a criação de uma
plataforma que utiliza como base uma integração entre Arduino e Raspberry Pi. A união
destas duas plataformas garante uma boa variedade de configurações de uso. A
configuração mais básica é a de dispositivo único (Figura 2.1), onde um Raspberry Pi
atua como um Controlador Lógico Programável (PLC) que, segundo HUDEDMANI
(2017), atua no recebimento e tratamento de dados do espaço de trabalho, e no envio
de comandos para os dispositivos que atuam o mesmo. No caso desta unidade de
comando, ele recebe dados e envia comandos para uma placa Arduino, que por sua
vez aciona dispositivos e atuadores e captura leituras da instrumentação do projeto. Um
exemplo para esta configuração seria um manipulador de função única, como um braço
robótico.
Figura 2.1: Esquema de configuração de dispositivo único.
Uma outra configuração possível é a de dispositivo múltiplo (Figura 2.2), onde um
Raspberry Pi controla diversas placas Arduino, cada uma com funções específicas com
diversos graus de interligação e níveis de hierarquia, como por exemplo um segmento
11
automatizado de uma linha de produção, requerindo diversas operações e
deslocamentos de um ou mais produtos.
Figura 2.2: Esquema de configuração de múltiplas placas Arduino.
Pode-se, ainda, utilizar diversos dispositivos comunicando-se entre si cada um
realizando tarefas independentes (Figura 2.3), mas possuindo a capacidade de utilizar
leituras de outros dispositivos na rede de informações para tomar decisões. Uma
possível utilização desta configuração é a de drones autônomos organizados em bando
(VÁSÁRHELYI et al., 2018). A movimentação em bando pode ser desejável em funções
de filmagens de grande dificuldade que requiram diferentes ângulos, como a gravação
de um carro de corrida em movimento. A comunicação entre os drones é essencial para
que os mesmos não colidam entre si ou gravem ângulos desnecessários, bem como
garantir que a posição relativa e velocidade de voo estejam de acordo com os
parâmetros definidos pelo operador.
12
Figura 2.3: Esquema de configuração de múltiplos dispositivos interligados.
Um esquema de controle com múltiplos Raspberry Pi, seguindo o conceito de Sistema
de Controle Distribuído (DCS), definido por HUDEDMANI (2017) como um sistema onde
os elementos de controle não estão centralizados, mas distribuídos entre diversos
controladores, também é possível. Um Raspberry Pi é usado como uma central de
comando para os demais, dividindo as funções de tratamento de dados e tomada de
decisões entre os controladores. Tal configuração pode ter dois níveis de hierarquia,
como demonstrado na Figura 2.4, ou mais níveis, de acordo com as necessidades do
projeto.
Figura 2.4: Esquema de configuração de múltiplos dispositivos controlados por Raspberry Pi.
13
A transmissão de dados entre Rasperry Pi e Arduino(s) pode ser realizada
através de diferentes meios como: vínculos físicos (condutores elétricos, USB, fibra
ótica, ADSL, BNC) ou sem fio (rádio frequência, wi-fi e bluetooth). Dessa forma pode-se
ter, por exemplo, a localização remota de determinados dispositivos mantendo-se a
comunicação entre eles ou a uma unidade de controle centralizada.
2.2. Conceito da Plataforma
Este trabalho tem como objetivo a criação de uma plataforma didática de utilização pelo
Laboratório de Robótica da UFRJ (LabRob), para uso durante as aulas das disciplinas
Automação e Robótica (EEK557) e Laboratório de Engenharia Mecânica I - módulo
Robótica (EEK 351), além do uso geral por alunos e professores para projetos diversos.
Para atender às necessidades do laboratório, propõe-se a utilização de uma unidade de
controle baseada em Raspberry Pi e Arduino. A integração das duas placas propicia um
controlador versátil de baixo custo com o Arduino, e um computador pequeno e de baixo
consumo com o Raspberry Pi para tratamento de dados e tarefas mais complexas,
incluindo o controle de múltiplas placas Arduino. Para os propósitos deste trabalho, uma
arquitetura de dispositivo único foi escolhida, realizando a comunicação entre as duas
placas via USB. A interface operador-máquina situa-se em um outro computador que
controla e monitora a atividade ligada ao Raspberry Pi remotamente via comunicação
sem fio (Figuras 2.5 e 2.6).
Figura 2.5:Esquema simplificado da unidade de controle.
14
Figura 2.6: Esquema simplificado da parte elétrica.
Intenta-se, também, utilizar a linguagem Python como base dos programas da
plataforma, visto que esta é a linguagem de programação ensinada nos cursos de
computação do ciclo básico de engenharia da UFRJ e possui uma vasta biblioteca de
recursos e informações disponíveis para uso livre.
2.3. Componentes Principais da Plataforma
2.3.1. Arduino
Como mencionado anteriormente, a plataforma Arduino (Figura 2.7) possui grande
versatilidade em função de sua programação em código aberto e sua arquitetura aberta
que facilitam a realização de alterações ou modificações à placa necessárias para sua
adequação a um projeto. Tal característica também reduz seu custo drasticamente, visto
que outros fabricantes podem vender versões genéricas com especificações idênticas
ou até mesmo alteradas para determinados propósitos quando comparadas às originais.
15
Diversos tipos de atuadores e aquisitores de dados podem ser utilizados pela placa
Arduino, seja em forma padrão ou com circuitos de adaptação. Motores DC, de passo,
servomotores, de diferentes faixas de operação (corrente e voltagem) podem ser
controlados diretamente pelo Arduino ou com auxiílio de placas ou circuitos
adaptadores.
Figura 2.7: Arduino Uno. (ARDUINO, 2018)
2.3.2. Shields e complementos
Existem no mercado placas de adaptação prontas para a plataforma Arduino chamadas
de Shields. Estas placas apresentam uma opção mais imediata para alguns projetos,
eliminando a necessidade de criar um adaptador específico para um sistema ou
disponibilizando uma base que facilite tal adaptação, dado que Shields geralmente
seguem a filosofia de arquitetura aberta das placas Arduino. Abaixo, temos alguns tipos
comuns de Shields e dispositivos que são utilizados por Shields.
a) Shield Motor Driver
Estes Shields permitem que o Arduino controle um ou mais motores DC, podendo
trabalhar com voltagens e correntes diferentes daquelas de operação do próprio
Arduino. Estas placas geralmente possuem funções de controle de ativação, velocidade
e sentido de rotação dos motores.
16
b) Módulo XBee
O módulo Xbee permite que a placa Arduino se comunique com outros dispositivos por
conexão Bluetooth, aumentando suas capacidades de controle sem fio. Diversos tipos
de Shields incluem um encaixe para sua utilização, podendo ser específicos para a
conexão Bluetooth ou integrados com diversas outras funções.
c) Shields CNC / Motor de passo
Shields CNC permitem a utilização de drivers padrão de motor de passo pela placa
Arduino. Estas placas são voltadas para a utilização da plataforma em máquinas de
impressão 3D ou quaisquer sistemas que utilizem motores de passo, sendo sua
funcionalidade limitada pelos drivers e modelo de Arduino aos quais estas são
projetadas.
d) Shield Ethernet
Como o nome implica, o Shield Ethernet permite que a placa Arduino conecte-se com
outros dispositivos via internet, possibilitando que a mesma possa ser controlada
remotamente ou enviar dados pela rede.
e) Shield GPS
O módulo GPS destes Shields permite a aquisição de dados de posicionamento via
satélite que podem ser úteis para projetos de mapeamento ou rastreamento. Os dados
podem ser armazenados em um cartão micro SD, instalado na própria placa, para
análise posterior.
f) Shield GSM/GPRS
Estes Shields podem fazer uso de um chip GSM para que o Arduino seja capaz de
realizar chamadas de voz, envio de mensagens SMS ou até mesmo conectar-se à
Internet por meio de serviços 4G/3G.
2.3.3. Raspberry Pi
Devido ao objetivo de versatilidade em nossa plataforma, deseja-se ter, além de
versatilidade de atuadores e sensores, uma capacidade de tratamento de dados e
processamento que permita uma maior complexidade de tarefas para projetos que
tenham tal necessidade. Como a plataforma Arduino não possui tais funções por ser
17
apenas uma placa de controle, o RasberryPi (Figura 2.8) torna-se o complemento ideal
para o projeto. Ele permite, ainda, o controle via internet da plataforma didática, bem
como sua utilização em projetos móveis devido ao seu tamanho compacto e capacidade
de alimentação por baterias.
Figura 2.8: Raspberry Pi 3 Modelo B.(RASPBERRY PI FOUNDATION, 2018)
2.3.4. Mecanismo controlado
Para que a plataforma didática possa ser utilizada como tal, é necessário que a mesma
possua um mecanismo com uma função ou objetivo claros que demonstre o
funcionamento do sistema, bem como princípios de cinemática e lógica de programação
por trás das ações de um robô.
Alguns mecanismos possíveis para uma aplicação didática, dadas suas naturezas de
simples compreensão, são uma bancada XY – similar à bancada do LabRob
mencionada no item 1.1.6 – ou um manipulador com 2 ou mais graus de liberdade que
move sua extremidade ou um objeto num campo de trabalho bi ou tridimensional. O
mecanismo pode realizar diferentes tipos de tarefas e processos contanto que sua
complexidade não seja alta o suficiente para prejudicar sua função didática.
De forma a manter um bom grau de simplicidade ao mecanismo da plataforma, decidiu-
se utilizar um manipulador mecânico de 3 graus de liberdade com um dispositivo de
escrita em sua extremidade (Figura 2.9) em conjunto com a unidade de controle para
as aulas experimentais do laboratório. A finalidade deste manipulador é escrever letras
ou palavras em uma folha de papel como forma de demonstrar os princípios
mencionados anteriormente. A concepção deste mecanismo é parte integrante deste
trabalho de conclusão de curso.
18
Figura 2.9: Desenho do manipulador com dispositivo de escrita.
A escolha deste dispositivo deu-se, também, pelo fato de que esta é uma configuração
comumente utilizada como exemplo de princípios de cinemática e dinâmica em robótica,
possuindo análises detalhadas e comprovadas para comparação e consulta pelos
alunos que farão uso da plataforma.
Para esta aplicação, devem ser levados em conta parâmetros fundamentais para seu
funcionamento que são o comprimento dos elos, o deslocamento e posições angulares
máxima e mínima dos elos e a altura da ponta da caneta até a superfície do papel. O
comprimento e as posições angulares são avaliados por meio de uma análise de volume
de trabalho, realizada no capítulo 4, ao passo que o deslocamento e posição da caneta
em relação ao papel dependem das especificações das peças utilizadas na montagem
do mecanismo, que também são avaliadas no capítulo 4.
Embora tenham sido feitos cálculos e elaborados os desenhos deste mecanismo, um
protótipo deste não foi produzido.
19
3. ESPECIFICAÇÃO DA PLATAFORMA
O esquema apresentado na Fig. 3.1 detalha o esquema lógico geral da plataforma
didática. Como pode-se observar, utiliza-se a configuração de dispositivo único para a
unidade de controle, esta que é controlada e operada por um computador conectado a
ela por comunicação sem fio. A unidade de controle, por sua vez, comanda três
servomotores (S3302 e SG90) presentes no manipulador: dois deles responsáveis pelo
movimento no plano XY e um terceiro responsável por mover a caneta necessária para
escrever no papel.
Figura 3.1: Esquema lógico geral simplificado.
3.1. Unidade de controle
3.1.1. Raspberry Pi 3
Como “cérebro” da unidade de controle, utiliza-se um Raspberry Pi 3 Modelo B
certificado pela Anatel. Possuindo um processador e memória RAM superiores quando
comparados ao UNO, ele pode realizar cálculos complexos e processamento de dados
20
que uma placa Arduino seria incapaz de fazer. As funções de comunicação sem fio são
supridas por um adaptador Wi-Fi e Bluetooth integrados, permitindo que o mesmo possa
ser controlado por um outro computador ou celular remotamente, sem a necessidade
de conectar periféricos (mouse, teclado e monitor) ao Raspberry Pi. A comunicação com
a placa Arduino é feita através de uma de suas quatro portas USB. A especificação se
encontra no Anexo 3A.
3.1.2. Arduino UNO
A placa Arduino UNO R3 funcionará como o controle efetivo dos sensores e atuadores.
A escolha do modelo UNO se dá pelo fato deste ser o modelo mais comum e conhecido,
possuindo preço muito acessível quando se consideram versões genéricas (algumas
chegando à faixa de R$50,00) e um número maior de Shields e placas de adaptação
disponíveis. No contexto do projeto, o UNO utilizará sua entrada USB tanto para fins de
comunicação com o Raspberry Pi quanto para sua própria alimentação necessária para
seu funcionamento básico. A especificação se encontra no Anexo 3B.
3.1.3. Interface
A interface operador-máquina se dá através da comunicação sem fio da unidade de
controle com outro dispositivo que, neste caso, trata-se de um computador. A partir
deste, é possível controlar todos os aspectos do Raspberry Pi remotamente com o
auxílio de um software de acesso remoto que será discutido no capítulo 6.
3.2. Manipulador com dispositivo de escrita
3.2.1. Descrição do manipulador
Como mencionado no item 2.3.4, o manipulador a ser utilizado com a unidade de
controle consiste de dois elos (corpos rígidos) vinculados por juntas de rotação em um
plano, dotado de um dispositivo de escrita em sua extremidade que move uma caneta
verticalmente (3 graus de liberdade) (Figuras 3.2 e 3.3). A função é escrever letras do
alfabeto ou palavras em uma folha de papel, a fim de demonstrar o funcionamento da
plataforma e de princípios mecatrônicos.
21
Figura 3.2: Desenho esquemático do manipulador com dispositivo de escrita.
Figura 3.3: Desenho esquemático do manipulador (vista superior).
O manipulador é movimentado por meio de dois servomotores Futaba S3302 (Anexo
3C) situados no primeiro elo que são acionados por meio do sinal enviado pela unidade
de controle. Um sistema de transmissão por meio de polias e correias transfere o
movimento para os elos, que giram em torno de suas árvores, cuja rotação é facilitada
por rolamentos. O mecanismo é fixado em uma mesa ou outra superfície por meio da
base, fixada na árvore de rotação do elo 1 (Figura 3.4).
Elo 1
Elo 2
Elo 2
Elo 1
Elo 0
22
Componente Descrição
1 Polia HTD-30M-6F
2 Correia 216-3M-06
3 Rolamento INA/FAG 6200A
4 Árvore do Elo 2
5 Servomotor Futaba S3302
6 Base
7 Árvore do Elo 1
Figura 3.4: Desenho esquemático do primeiro elo do manipulador com lista de componentes.
3.2.2. Descrição do dispositivo de escrita
O dispositivo de escrita, por sua vez, trata-se de um mecanismo de movimento vertical
de uma caneta acionado por um servomotor TowerPro SG90, cujo movimento de
rotação é transformado em um linear com auxilio de uma peça móvel guiada (Elevador),
elevando ou abaixando uma chapa que segura uma caneta para efetuar ou terminar o
contato de sua ponta com a superfície de escrita (Figuras 3.5 e 3.6).
1 2
5
3
6 7 5 3
4 2 1 1 1
23
Figura 3.5: Dispositivo de escrita.
24
Componente Descrição
1 Suporte
2 Servomotor TowerPro SG90
3 Chapa e Fixador da caneta
4 Guias (x2)
5 Elevador
6 Molas (x2)
7 Caneta
Figura 3.6: Desenho do dispositivo de escrita com caneta e lista de componentes.
7
1
2
5
3
1 4
6
25
4. DETALHAMENTO DO DISPOSITIVO
MECATRÔNICO
4.1. Finalidade de Uso
Para que a plataforma possa ser efetivamente utilizada como uma ferramenta didática,
é necessário um mecanismo que sirva como exemplo ou meio de visualização da
interação entre a parte programacional e a física. Desta forma, idealizou-se um
manipulador de 3 graus de liberdade cuja função é escrever letras simples do alfabeto
em uma folha A6 (105x146mm). A simplicidade deste mecanismo permite uma fácil
compreensão da cinemática e dos princípios de projeto e programação envolvidos no
funcionamento da plataforma (Figura 4.1).
Figura 4.1: Vista superior do manipulador.
4.2. Parte Mecânica
O manipulador consiste em 2 elos acionados por servomotores e um mecanismo de
movimento vertical para uma caneta, controlado por um outro servomotor, que realizará
as marcações na folha. Os movimentos angulares dos elos realizam o deslocamento da
caneta ao longo do plano.
As dimensões de comprimento dos elos do robô são de 300mm para o primeiro elo e
250mm para o segundo elo que irá suportar o sistema de escrita. Como mencionado
anteriormente, eles serão movimentados por meio de servomotores. Cada elo possui
um conjunto árvore e rolamento que serve como ponto de apoio e rotação (Figura 4.2).
26
Figura 4.2: Vista direita do manipulador.
4.3. Dispositivo de Escrita
O mecanismo da caneta consiste em uma peça móvel guiada que é movimentada
verticalmente por um servo, seu movimento angular transformado em linear com auxílio
de um oblongo (Figura 4.3).
Figura 4.3: Mecanismo de elevação da caneta. (a) posição superior, (b) posição inferior.
O instrumento de escrita a ser utilizado é uma caneta de modelo Bic Cristal ou similar
pela sua substituição fácil.
27
4.4. Caracterização do Manipulador
4.4.1. Parâmetros de Posicionamento
Através do método de Denavit-Hartemberg (D-H) (ROMANO, 2017), pode-se determinar
os parâmetros de posicionamento (posição e orientação) do manipulador. No Anexo 4A
são apresentadas as principais definições deste método.
Os parâmetros D-H para o manipulador são dados pela Tabela 4.1 e Figuras 4.4 e 4.5:
Elo 𝑎𝑖 [𝑚𝑚] 𝛼𝑖 [𝑟𝑎𝑑] 𝑑𝑖 [𝑚𝑚] 𝜃𝑖 [𝑟𝑎𝑑]
0 0 0 𝑑1 0
1 L1 0 0 𝜃1 (𝑡)
2 L2 0 0 𝜃2(𝑡)
3 0 0 𝑑3(𝑡) 0
Tabela 4.1: Parâmetros de Denavit-Hartemberg
Figura 4.4: Localização dos parâmetros D-H no manipulador.
28
Figura 4.5: Dimensões principais do manipulador.
Para poder determinar os valores necessários dos parâmetros 𝛳1 e 𝛳2 para o
posicionamento da caneta, é necessário determinar as equações de posição do robo.
Como a caneta é perpendicular à superfície de escrita e consequentemente à folha e
sendo o contato da caneta pontual, o posicionamento do Sistema de Coordenadas de
Referência 3 (base {3}) se restringe a sua coordenada da origem, logo, os cálculos de
orientação do ponto de contato não foram obtidos. Para essa condição, a orientação da
base {3} foi considerada coincidente à orientação da base {2} (Figura 4.6).
Figura 4.6: Orientação dos SCRs no manipulador (Vista superior).
A figura 4.6 ilustra uma representação simplificada do manipulador no plano cartesiano.
A base {0} é solidária ao ponto de fixação do robô, a base {1} é solidária à rotação do
29
elo 1 e a base {2} é solidária à rotação da base 2. O parâmetro 𝛳1 representa o ângulo
de rotação do elo 1 em relação à base {0} e o parâmetro 𝛳2 representa o ângulo de
rotação do elo 2 em relação à base {1}. Os comprimentos dos elos 1 e 2 são,
respectivamente, L1 e L2 A matriz de transformação de {1} para {0} fica:
𝑇1 0 = [
𝐶𝑜𝑠𝜃1 −𝑆𝑒𝑛𝜃1 0 𝐿1𝐶𝑜𝑠𝜃1
𝑆𝑒𝑛𝜃1 𝐶𝑜𝑠𝜃1 0 𝐿1𝑆𝑒𝑛𝜃1
0 0 1 𝑑1
0 0 0 1
]
Ao passo que a matriz transformação de {2} para {1} fica:
𝑇2 1 = [
𝐶𝑜𝑠𝜃2 −𝑆𝑒𝑛𝜃2 0 𝐿2𝐶𝑜𝑠𝜃2
𝑆𝑒𝑛𝜃2 𝐶𝑜𝑠𝜃2 0 𝐿2𝑆𝑒𝑛𝜃2
0 0 1 00 0 0 1
]
A ponta da caneta tem sua posição efetiva representada pela base 3, como ilustrado na
Figura 4.5. Esta base possui uma posição vertical variável representada por 𝑑3, de
forma que a caneta possa manter ou encerrar contato com a superfície de escrita. A
matriz de transformação de {3} para {2} é:
𝑇3 2 = [
1 0 0 00 1 0 00 0 1 𝑑3
0 0 0 1
]
A partir das matrizes anteriores, pode-se definir a matriz de transformação de {3} para
{0} como:
𝑇3 0 = 𝑇1
0 𝑇2 1 𝑇3
2
𝑇3 0 = [
𝐶𝑜𝑠(𝜃1 + 𝜃2) −𝑆𝑒𝑛(𝜃1 + 𝜃2) 0 𝐿1𝐶𝑜𝑠𝜃1 + 𝐿2𝐶𝑜𝑠(𝜃1 + 𝜃2)
𝑆𝑒𝑛(𝜃1 + 𝜃2) 𝐶𝑜𝑠(𝜃1 + 𝜃2) 0 𝐿1𝑆𝑒𝑛𝜃1 + 𝐿2𝑆𝑒𝑛(𝜃1 + 𝜃2)0 0 1 𝑑1 + 𝑑3
0 0 0 1
]
Para calcular a posição da caneta em relação à fixação do robô é preciso transformar o
vetor de posição da caneta Pc para a base {0}. Definindo:
𝑃𝑐 = (0 0 0 1)𝑇
2
𝑃𝑐 = 0 𝑇
03 𝑃𝑐
3
𝑃𝑐 = (
𝐿1𝐶𝑜𝑠𝜃1 + 𝐿2𝐶𝑜𝑠(𝜃1 + 𝜃2)
𝐿1𝑆𝑒𝑛𝜃1 + 𝐿2𝑆𝑒𝑛(𝜃1 + 𝜃2) 𝑑1 + 𝑑3
1
) 0
30
4.4.1. Definição dos valores dos parâmetros
Para garantir que o manipulador possa atuar em toda a área do papel, decidiu-se utilizar
as dimensões de 300 mm e 250 mm para os comprimentos L1 e L2 do primeiro e
segundo elos respectivamente. Os servomotores de movimento do robô possuem um
curso de 180 graus, desta forma, o primeiro elo possui ângulo de posição 𝛳1 com valor
máximo de 90 graus e mínimo de -90 graus, ao passo que o segundo elo possui ângulo
de posição 𝛳2 situado em 0° < 𝛳2 ≤ 90°. A diferença de cursos entre os elos deve-se
ao fato de que possíveis problemas de singularidade podem impedir que o programa
ache uma solução única para a posição desejada, impossibilitando seu funcionamento.
A limitação de curso do segundo elo garante que apenas uma solução seja possível
(Figura 4.7).
Figura 4.7:Distâncias do manipulador.
A distância d1 possui 101,5 mm, já a distância d3 é variável, tendo valores máximo e
mínimo de 101,5 mm e 88,4 mm respectivamente.
4.4.3. Volume de Trabalho Limite
O volume de trabalho limite de um dispositivo é descrito como a área ou região na qual
o mesmo é capaz de alcançar. Dado o fato de que o manipulador atua efetivamente
apenas em um plano bidimensional, elaborou-se a área de trabalho do mesmo.
A área de trabalho do manipulador foi determinada com o auxílio do programa
Macromedia Flash 8, fazendo uso de suas funções de desenho vetorial. Utilizando as
dimensões de 300 mm e 250 mm para os elos 1 e 2, respectivamente, duas linhas retas
foram desenhadas no programa para representar estas peças (Figura 4.8).
31
Figura 4.8: Representação bidimensional do manipulador.
Em seguida, desenhou-se um arco de 90 graus (ângulo 𝛳2) utilizando comprimento do
elo 2 como raio e seu eixo de rotação como centro para representar seu curso total de
90 graus, como mencionado anteriormente (Figura 4.9).
Figura 4.9: Representação do curso possível do elo 2.
Após isto, o conjunto foi movimentado em torno da extremidade do elo 1 (ângulo 𝛳1) de
forma a representar toda a área alcançável pela extremidade do dispositivo no plano.
Raios equivalentes da extremidade do manipulador para as situações de início e final
de curso para ambos os elos foram traçados para auxiliar na visualização da área de
trabalho (Figura 4.10).
Figura 4.10: Raios equivalentes do manipulador (Linha sólida: elo 2 em 0 grau / Linha
pontilhada: elo 2 em 90 graus).
32
Finalmente, utilizando os raios equivalentes, desenha-se o curso da extremidade do
manipulador nas situações de início e fim do curso do elo 2. Consequentemente,
encontra-se a área de trabalho limite (Figura 4.11).
Figura 4.11: Elaboração da área de trabalho limite.
Após uma análise da área de trabalho, concluiu-se que uma folha A6 posicionada 25
mm verticalmente e 400 mm horizontalmente do eixo de rotação do elo 1 está contida
dentro da região na qual o manipulador pode escrever (Figura 4.12).
Figura 4.12: Área de trabalho efetiva com folha A6 e mesa com posição alternativa.
33
4.5. Componentes
4.5.1. Polias
Para evitar exercer cargas adicionais sobre os servomotores, um sistema de
transmissão de polias é utilizado. A escolha das polias e correias foi feita de acodo com
os catálogos da SCHNEIDER LTDA. (2019).
As polias foram escolhidas de forma a acomodar rolamentos INA/FAG 6200A
(SCHAEFFLER AG, 2019) aos quais o Laboratório de Robótica já dispõe. O diâmetro
interno deste modelo é de 10 mm, portanto, deseja-se uma polia cujo furo possua uma
dimensão similar. Desta forma, optou-se por utilizar as polias de modelo HTD-30M-6F
cujo furo pode tem diâmetro mínimo de 6 mm e máximo de 11 mm. Como não há
necessidade de uma razão de transmissão diferente de 1:1, todas as polias terão as
mesmas dimensões.
A correia, por sua vez, foi escolhida de acordo com a equação 4.1 (ROMANO, 2016),
que representa o cálculo de comprimento da correia:
𝑃𝐿 = 2𝐶𝐷 + [1,57. (𝑃𝐷 + 𝑝𝑑)] +(𝑃𝐷 − 𝑝𝑑)2
4𝐶𝐷 (4.1)
Onde PL é o comprimento da correia, CD é a distância entre os centros das polias e PD
e pd são os diâmetros da polia maior e menor respectivamente. Como os diâmetros PD
e pd são iguais, a equação 4.1 torna-se:
𝑃𝐿 = 2𝐶𝐷 + [1,57. (2𝑃𝐷)] (4.2)
Escolhendo CD=60mm para que haja um espaçamento suficiente entre as polias caso
haja a necessidade de manusear este espaço, tem-se:
𝑃𝐿 = 209,85𝑚𝑚
Analisando o catálogo de correias Schneider, a correia com o comprimento mais
próximo é a correia 216-3M-06. Como o comprimento desta é de PLcorreia=216mm, é
necessário corrigir o valor CD da distância das polias:
𝐶𝐷𝑐𝑜𝑟𝑟𝑖𝑔𝑖𝑑𝑜 = [𝑃𝐿𝑐𝑜𝑟𝑟𝑒𝑖𝑎 − 1,57. (2𝑃𝐷)]/2
𝐶𝐷𝑐𝑜𝑟𝑟𝑖𝑔𝑖𝑑𝑜 = 63,02𝑚𝑚
34
Estas polias precisam ser furadas de acordo com os desenhos disponíveis no Anexo 4B
de forma a fixá-las em seus respectivos servomotores, árvores e elos.
4.5.2. Análise estrutural dos elos
Os elos do robô foram, primeiramente, idealizados como placas de alumínio de 2mm de
dimensões 300x50 mm e 250x25 mm. A escolha do alumínio como o material deu-se
em função de sua relativa leveza e sua disponibilidade no LabRob (Figura 4.13).
Figura 4.13: Idealização inicial dos elos.
De forma a garantir que a posição da caneta não seja comprometida, uma análise da
deflexão total dos dois elos deve ser efetuada. Uma análise de resistência, entretanto,
foi julgada desnecessária considerando o fato de que as cargas às quais o sistema é
submetido são muito pequenas. As análises são realizadas com base na configuração
de 𝜃1 = 𝜃2 = 0, na qual há uma maior deflexão vertical.
Considera-se o segundo elo, aquele que irá suportar o mecanismo de escrita, como uma
viga engastada com uma carga em sua extremidade (Figura 4.14):
35
Figura 4.14:Esquema de cargas do elo 2.
Segundo CRANDALL (1978), a flecha resultante do peso do mecanismo da caneta pode
ser calculada a partir da equação 4.3:
𝑓𝐹 =𝐹𝑙3
3𝐸𝐼 (4.3)
Onde 𝑓𝐹 é a deflexão, 𝐹 é a carga exercida na ponta, 𝑙 é o comprimento do elo, 𝐼 é o
momento de inércia no eixo perpendicular ao plano e 𝐸 é o módulo de elasticidade do
alumínio.
Para a situação do peso distribuído, a flecha pode ser calculada pela equação 4.4:
𝑓𝑞 =𝑞𝑙4
8𝐸𝐼 (4.4)
Onde 𝑓𝑞 é a deflexão, 𝑞 é o peso distribuído ao longo de todo o elo, 𝑙 é o comprimento
do elo, 𝐼 é o momento de inércia no eixo perpendicular ao plano e E é o módulo de
elasticidade do alumínio.
A carga q pode ser obtida através da equação 4.5:
𝑞 = 𝑔𝐴𝜇 (4.5)
Onde 𝑔 é a aceleração da gravidade, 𝐴 é a área da seção transversal do elo e 𝜇 é a
massa específica do material, neste caso Alumínio.
36
Em função do perfil retangular do primeiro elo, o momento de inércia pode ser calculado
utilizando a eq 4.6:
𝐼 =𝑏𝑡3
12 (4.6)
Onde 𝑏 é a largura do elo e 𝑡 a espessura.
Realizando os cálculos considerando E=69 GPa para o alumínio e uma carga 𝐹2 de 30
g ou 0,29 N para o mecanismo de escrita, foram encontradas flechas 𝑓𝐹2 e 𝑓𝑞2 de 1,33
mm e 0,56 mm, ocasionadas pelo mecanismo de escrita e o peso do elo
respectivamente. Pelo princípio de superposição, a flecha total 𝑓2 é de 1,89 mm. Uma
deflexão de quase 2 mm é prejudicial para o movimento vertical da caneta, portanto, foi
prosta a utilização de um perfil L.
O perfil L proposto tem dimensões de 25x10x250 mm e possui 2 mm de expessura. Sua
fabricação é feita a partir de um perfil L de alumínio de dimensões 51x31x1000 mm de
mesma espessura (Figura 4.15).
Figura 4.15:Novo perfil do elo 2.
Neste caso, tem-se que o peso distribuído q é:
𝑞2 =(25 × 2 + 8 × 2) × 2700 × 9,81
10003 = 1,75 × 10−3𝑁/𝑚𝑚
Nesta situação, deve-se considerar este perfil como uma seção composta por duas
seções retangulares (Figura 4.16).
37
Figura 4.16: Representação da seção transversal do elo 2.
Para calcular o momento de inércia, é necessário determinar a posição vertical do
centróide do perfil utilizando a equação 4.7:
�̅� =𝐴𝑠1𝑦𝑠1 + 𝐴𝑠2𝑦𝑠2
𝐴𝑠1 + 𝐴𝑠2 (4.7)
Onde 𝐴𝑠1 e 𝑦𝑠1 são, respectivamente, a área e a posição vertical do centróide da seção
1 e 𝐴𝑠2 e 𝑦𝑠2 representam os mesmos valores para a seção 2. Considerando as
dimensões na figura 4.16, tem-se:
�̅�2 = 7,79𝑚𝑚
O momento de inércia é calculado através da equação 4.8:
𝐼 = 𝐼𝑠1 + 𝐴𝑠1𝑑𝑠12 + 𝐼𝑠2 + 𝐴𝑠2𝑑𝑠2
2 (4.8)
Onde 𝐼𝑠1 e 𝐼𝑠2 são os momentos de inércia das seções 1 e 2, 𝐴𝑠1 e 𝐴𝑠2 representam as
áreas das seções 1 e 2, e 𝑑𝑠1 e 𝑑𝑠2
representam a distância do centroide de cada seção
em relação ao centroide do perfil L. Utilizando a equação 4.6 e substituindo os valores
na equação 4.8, tem-se:
𝐼2 =2 × 83
12+ 16 × 14,35 +
25 × 23
12+ 50 × 1,46 = 404,60𝑚𝑚4
38
Substituindo novamente nas equações anteriores, as flechas da carga 𝑓𝐹2 e do peso
distribuído 𝑓𝑞2 são, respectivamente, de 0,03 mm e 0,06 mm. Por superposição, tem-se
uma flecha total 𝑓2 de 0,09 mm, uma deflexão aceitável para o movimento vertical da
caneta, cujo curso é de 14.45 mm.
Considerando os problemas encontrados no segundo elo, opta-se por também utilizar
um perfil L para o segundo elo, de dimensões 51x31x300mm com 2mm de espessura.
O segundo elo também é tratado como uma viga engastada e está sujeito a carga e
momento exercidos pelo primeiro elo, e seu peso distribuído (Figura 4.17):
Figura 4.17: Esquema de cargas do elo 1.
Para o caso do momento, utiliza-se a equação 4.9:
𝑓𝑀 =𝑀𝑙2
2𝐸𝐼 (4.9)
Onde 𝑓𝑀 é a deflexão, 𝑀 é o momento exercido na extremidade do elo e os demais
parâmetros são os mesmos das equações 4.3 e 4.4.
Utilizando a equação 4.5, temos que o peso distribuído do elo é:
𝑞1 =(51 × 2 + 29 × 2) × 2700 × 9,81
10003 = 4,24 × 10−3𝑁/𝑚𝑚
A carga 𝐹1, resultante da soma do peso do segundo elo com o peso do mecanismo da
caneta, é de 0,73 N. O momento 𝑀1, por sua vez, é de 127,19 N.mm.
39
O momento de inércia do primeiro elo é calculado da mesma forma que o segundo elo
(Figura 4.18). Utilizando as equações 5.6, 5.7 e 5.8, tem-se :
Figura 4.18: Representação da seção transversal do elo 1.
�̅�1 = 24,38𝑚𝑚
𝐼1 =2 × 293
12+ 58 × (14,5 − 24,38)2 +
51 × 23
12+ 102 × (30 − 24,38)2
𝐼1 = 12982,02𝑚𝑚4
Substituindo nas equações anteriores, tem-se que a flecha da carga 𝑓𝐹1 é
de 7.34 × 10−3𝑚𝑚, a flecha do peso distribuído 𝑓𝑞2 é de 4.79 × 10−3𝑚𝑚 e a flecha de
momento 𝑓𝑀1 é de 6.39 × 10−3𝑚𝑚. Pelo princípio de superposição, tem-se uma flecha
total 𝑓1 de 0,018 mm. Quando transferida para a extremidade do elo 2, esta flecha torna-
se uma de 0,033 mm.
Também é necessário avaliar o ângulo de deflexão total da extremidade para
deteriminar o desvio vertical ocasionado por este. As equações 4.10, 4.11 e 4.12
determinam o ângulo ocasionado pelo mecanismo de escrita, peso próprio e momento,
respectivamente. Os parâmetros possuem a mesma definição das equações 4.3, 4.4 e
4.9.
𝛾𝐹 =𝐹𝑙2
2𝐸𝐼 (4.10)
40
𝛾𝑞 =𝑞𝑙3
6𝐸𝐼 (4.11)
𝛾𝑀 =𝑀𝑙
𝐸𝐼 (4.12)
O ângulo de deflexão 𝛾𝐹1 ocasionado pelo mecanismo é de 3.67 × 10−5 𝑟𝑎𝑑, o ângulo
do peso distribuído 𝛾𝑞1 é de 2.13 × 10−5 𝑟𝑎𝑑 e o ângulo do momento 𝛾𝑀1 é de
4.26 × 10−5 𝑟𝑎𝑑, totalizando um ângulo de 1 × 10−4𝑟𝑎𝑑. Na situação de 𝜃1 = 𝜃2 = 0, a
extremidade do segundo elo irá se deslocar 0,025 mm.
Somando todas as deflexões e deslocamentos, tem-se uma deflexão total de 0,148 mm
aceitável para o dispositivo.
4.5.3. Caracteríticas dos elos
O elo 1 possui 2 encaixes em sua parte mais larga nos quais os servomotores são
posicionados. Oito furos de 3 mm de diâmetro, posicionados próximos a esses encaixes,
são utilizados para fixar os servomotores com parafusos M3. Dois furos pertos de suas
extremidades, concêntricos à rebaixos, são utilizados para passar as árvores nas quais
os elos irão girar e os rolamentos necessários para tais movimentos (Figura 4.19).
Figura 4.19: Elo 1.
41
O elo 2, por sua vez, possui 6 furos de 3 mm de diâmetro posicionados em sua parte
mais larga. Quatro destes furos são utilizados para fixar o elo 2 na Polia Elo 2 com 4
parafusos M3. Os outros 2 furos presentes na extremidade oposta são utilizados para
fixar o mecanismo de escrita também com parafusos M3. Parte da parte mais fina é
removida para permitir que os parafusos sejam acomodados (Figura 4.20).
Figura 4.20: Elo 2.
4.5.4. Rolamentos
Como mencionado anteriormente, os rolamentos escolhidos para os eixos do robô são
de modelo INA/FAG 6200A, selecionados pela sua disponibilidade no LabRob. Eles
possuem diâmetro externo de 30mm, diâmetro interno de 10mm e espessura de 9mm.
4.5.5. Árvores
As árvores nas quais os elos giram em torno possuem dimensões adaptadas para as
polias, rolamentos e servomotores.
A árvore do primeiro elo possui três segmentos de diferentes diâmetros, de forma a
acomodar o rolamento e a polia necessários para a movimentação do elo. O diâmetro
do segmento intermediáro é menor do que o diâmetro do segmento inferior, permitindo
a acomodação do diâmetro interno do rolamento e fixação deste com adesivo. O
segmento superior, por sua vez, possui o menor diâmetro de forma a acomodar o furo
da polia. Uma mossa também está presente, com altura adaptada para o furo roscado
42
da polia, de forma a permitir a fixação desta última. A árvore possui, ainda, um furo
roscado M6 na sua parte inferior, para sua fixação na base do dispositivo (Figura 4.21).
Figura 4.21: Árvore do elo 1.
Da mesma forma que a árvore do primeiro elo, a árvore do segundo elo também possui
três segmentos de diâmetros diferentes para acomodar um rolamento e uma polia. O
segmento inferior se acomoda no diâmetro interno do rolamento, que é fixado com
adesivo. O segmento superior, assim como a árvore do elo 1, acomoda o furo da polia,
que também é fixada com o auxílio de uma mossa na árvore (Figura 4.22).
Figura 4.22: Árvore do braço 2.
43
4.5.6. Dispositivo de escrita
Como mencionado no capítulo 3, o mecanismo de escrita tem o propósito de
movimentar verticalmente uma caneta de forma a efetuar o contato de sua ponta em
uma superfície (Figura 4.23). Para tal, o sistema é acionado por um servomotor
TowerPro SG90.
Figura 4.23: Dispositivo de escrita sem caneta.
O movimento vertical é efetuado através da transformação do movimento angular do
servomotor por meio do elevador (Figura 4.24). Um parafuso M1.6, já incluso com o
servomotor, é encaixado no braço do mesmo e passa por dentro de um oblongo
presente no elevador. Ao movimentar-se, o servomotor desloca o elevador
verticalmente, sua trajetória auxiliada por duas guias.
44
Figura 4.24: Elevador.
Uma chapa de 2mm de espessura é responsável por suportar e movimentar a caneta
(Figura 4.25). Ela possui um furo de 8mm que permite que a posição da caneta em
relação à superfície. seja ajustada. O elevador desloca esta chapa de suporte através
de duas molas Gutenkunst D-011X (GUTENKUNST, 2019), concêntricas às guias,
responsáveis por compensar qualquer deslocamento excessivo da caneta. Estas molas
são fixadas tanto no elevador quanto na chapa por meio de adesivo Loctite 496
(HENKEL LTDA., 2019) ou pontos de solda de estanho.
Figura 4.25: Suporte da caneta.
Para fixar a caneta na chapa, é utilizada uma peça cilíndrica com superfíce que pode
ser fixada à última com adesivo Loctite 496 (Figura 4.26). A caneta, por sua vez, também
é fixada à peça cilíndrica por meio de adesivo.
45
Figura 4.26: Fixador.
O servomotor é preso com parafusos a um perfil L, na face perpendicular à face às quais
as guias estão presas (Figura 4.27). Um recorte é feito na face de fixação do servomotor
para facilitar a montagem do parafuso M1.6 no sistema móvel. O braço do servo possui
um parafuso em sua ponta, localizado a 14.45mm do eixo de rotação, que empurra a
peça móvel. O arco de movimento total do servo é de 60 graus, 30 em sentido horário
e 30 em sentido anti-horário, totalizando um curso de 14.45mm.
Figura 4.27: Perfil L do dispositivo de escrita.
As guias possuem 3,9mm de diâmetro e 45mm de comprimento (Figura 4.28). Cada
uma delas possui um furo M2 de 12mm de profundidade para fixação no perfil L.
46
Figura 4.28: Guia do dispositivo.
4.5.7. Mesa e pés niveladores
Uma mesa foi elaborada de forma a garantir que a base e o papel estejam nivelados
em uma superfície plana (Figura 4.29). O manipulador e a mesa são fixados por meio
de quatro parafusos M8 com porcas e buchas apropriadas.
Figura 4.29: Mesa.
47
A mesa também possui oito pés NV-04-30 05803 (BAKELITSUL, 2019) (Figura 4.30)
idênticos de forma a garantir que a mesma possa ficar estável na superfície que for
colocada. Estes são fixados à mesa por meio de outros 8 furos, presentes nas
extremidades e no meio da mesa, com auxílio das porcas providas com os pés, fazendo
com que a mesa fique em uma posição elevada a 23 mm da superfície em que o
conjunto é colocado.
Figura 4.30: Pé da mesa (BAKELITSUL, 2019).
Finalmente, podemos observar o manipulador e a mesa montados em sua totalidade na
figura 4.31:
Figura 4.31: Manipulador e mesa montados.
48
5. DETALHAMENTO DA UNIDADE DE CONTROLE
5.1. Parte Elétrica
5.1.1. Demanda do circuito lógico
Para o funcionamento do Raspberry Pi e periféricos, é necessário, de acordo com a
Raspberry Pi Foundation, que o mesmo seja alimentado com uma tensão de 5V com
corrente de, pelo menos, 2A. Partindo destas especificações, a alimentação é feita com
uma fonte bivolt com saída de tensão de 5V e corrente de 2.2A através do socket micro
USB do Raspberry Pi. O Arduino é alimentado, por sua vez, pela porta USB regular do
Raspberry Pi, suprindo, de acordo com os dados disponibilizados pela Arduino, uma
corrente de até 500 mA para o microcontrolador e dispositivos conectados ao mesmo
(Figura 5.1).
Alternativamente, caso seja desejável utilizar a unidade em uma plataforma móvel, é
possível utilizar uma bateria com especificações similares para alimentar as placas.
Atualmente, existem carregadores de celular portáteis ou PowerBanks que possuem
saída de 5V à 2.1A, atendendo as necessidades do Raspberry Pi. Tomando como
exemplo um modelo com capacidade de 20000mAh, é possível manter o sistema
operando por aproximadamente 9 horas ininterruptas com uma única carga do
PowerBank.
5.1.2. Demanda do dispositivo
Servos similares aos modelos Futaba S3302 utilizados neste projeto possuem uma
demanda de corrente elétrica extremamente variável, podendo estar na faixa de 8 mA
em condição sem carga ou até mesmo na faixa de 800 mA em condição de stall torque
(Catálogos HITEC). Isso se deve ao fato de que a carga de trabalho influencia a corrente
demandada por estes atuadores.
Como mencionado anteriormente, a alimentação via porta USB para o Arduino
consegue suprir um máximo de 500 mA para a totalidade da placa e seus dispositivos.
Caso um ou mais atuadores requiram uma corrente superior para seu funcionamento,
não haverá o suficiente para que o Arduino continue ligado.
Para evitar que os atuadores dos braços não interfiram no funcionamento do Arduino
demandando mais energia do que ele pode suprir, um pack com quatro pilhas AA fará
49
a alimentação destes. Como o sinal de entrada dos servomotores é PWM, a voltagem
de 6V resultante das baterias não interfere na leitura do sinal de 5V enviado pelo
Arduino. O servomotor do mecanismo da caneta, por sua vez, é conetado diretamente
ao Arduino, sendo tanto alimentado quanto comandado por ele.
Figura 5.1: Esquema elétrico geral simplificado.
5.1.3. Pinos e circuito
Para que o Arduino possa controlar os servomotores, é necessário que os mesmos
possuam suas conexões de entrada vinculadas aos pinos digitais com capacidade de
sinal PWM (Figura 5.2). Partindo deste princípio, a entrada do servomotor do primeiro
braço é conectada ao pino 9, a do servomotor do segundo braço é conectada ao pino
11 e a do servomotor do mecanismo da caneta é conectada ao pino 3. A conexão de
alimentação dos servomotores S3302 é ligada ao conjunto de 4 pilhas AA mencionado
anteriormente. A conexão terra é conectada ao negativo do conjunto de pilhas e ao pino
terra (GND) da placa Arduino. O servomotr do mecanismo da caneta, por sua vez, tem
sua alimentação ligada ao pino de 5V do Arduino e seu terra também ligado ao pino
terra da placa.
50
Figura 5.2: Esquema de conexões dos servos e da placa Arduino.
51
6. CONTROLE, PROGRAMAÇÃO E
COMUNICAÇÃO
Figura 6.1: Fluxograma de operação do programa do manipulador.
Como já discutido anteriormente, o projeto tem como função escrever letras do alfabeto
de forma simples em uma folha A6, posicionada à 400mm horizontalmente da e 25mm
verticalmente da base (Figura 6.1 e 6.2).
52
Figura 6.2: Esquema de posicionamento da folha.
Para garantir simplicidade e facilidade de operação do robô, as letras são escritas
utilizando um quadrado de lado l como referência (Figura 6.3). A origem deste quadrado,
isto é, seu ponto inferior esquerdo, é o ponto ao qual o programa se refere quando
define-se a posição da letra. Desta origem define-se também o ângulo de inclinação da
letra, que nada mais é do que uma rotação do quadrado em torno da origem. Finalmente,
o tamanho da letra é definido pelo valor do lado l escolhido pelo usuário (Figura 6.4).
Figura 6.3: Letra na folha A6.
53
Para que a o usuário possa realizar tal tarefa, ele deverá fazer uso da unidade de
controle da plataforma. Como exposto no capítulo 4, a unidade é composta pelo
conjunto Raspberry Pi 3 e Arduino UNO. O código e os comandos são escritos na
linguagem Python no Raspberry Pi 3 e enviados via porta serial para o Arduino que, por
sua vez, envia os sinais necessários para movimentar os servomotores de acordo com
as instruções do operador.
A visualização e utilização da plataforma é feita através de outro computador ou até
mesmo um smartphone por meio de comunicação pela rede Wi-Fi. Tal interface é feita
por meio do software gratuito VNC Connect, permitindo acesso remoto ao desktop do
Raspberry Pi.
Utilizando a interface mencionada, o usuário deve executar, no Raspberry Pi via
interpretador do Python, o programa tcc_functions.py contendo as funções e parâmetros
necessários para a tarefa. Durante sua inicialização, o programa executa a classe
PyMata3, que atribui a placa Arduíno à uma variável (neste caso a variável uno), e em
seguida define pinos os pinos 3,10 e 11 como pinos de entrada para os servomotores
através da função uno.servo_config. Após a definição, o programa desloca o braço para
a posição inicial 𝛳1=0º 𝛳2=45º através da função uno.analog_write.
Para escrever uma letra, deve-se executar uma das funções de escrita por linhas de
comando (write_A, write_B, write_C,...) utilizando como entrada uma tupla contendo as
coordenadas de posição do quadrado de referêncialetra, o tamanho do lado em
milímetros (no código atual, o lado é 10 vezes o valor do input) e sua rotação em graus
em sentido anti-horário em torno da origem.
Figura 6.4: Esquema de posicionamento da letra.
54
Utilizando estas variáveis, o programa define os pontos aos quais a caneta será movida
por meio de uma lista presente dentro da função, específica para a letra, que determina
posições em função do lado do quadrado, e da função letter_coord. Em seguida, o
programa executa a função boundary_check para assegurar que os pontos não estarão
fora da folha (Figura 6.5) e, caso a checagem seja bem-sucedida, a função
multiple_point_trans é executada para calcular os parâmetros dos servomotores. A
função boundary_check2 é então usada para realizar uma nova checagem de limites
com os novos parâmetros obtidos. Enfim, caso esta última checagem não retorne algum
problema, as funções servos_movement_line, servos_movement_free e pen_active são
executadas diversas vezes em sequências que variam de letra para letra,
movimentando, posicionando e acionando a caneta para que a letra seja escrita.
Figura 6.5: Letra fora dos limites do papel.
6.1. Interface de operação do Raspberry Pi
A interface de operação do Raspberry Pi é feita por meio do método de Virtual
Networking Computing (VNC), que permite compartilhamento gráfico do desktop do
Raspberry Pi e o controle do mesmo de forma remota. Para realizar tal controle utiliza-
se o software gratuito VNC Connect da Real VNC, já instalado no sistema operacional
Raspian. Utilizando a versão de servidor do VNC Connect no Raspberry Pi e a versão
de visualizador no dispositivo do operador, seja este um computador ou smartphone, é
55
possível realizar o compartilhamento de tela através do IP local atribuído ao Raspberry
Pi pela rede Wi-Fi.
6.2. Bibliotecas de Phyton e Arduíno
O programa criado para o controle da plataforma faz uso de três bibliotecas de código
aberto: Sympy, FirmataPlus e PyMata.
As bibliotecas FirmataPlus e PyMata, desenvolvidas por YORINKS (2018), são
responsáveis pela comunicação da placa Arduino e do código em Python presente no
Raspberry Pi. A biblioteca FirmataPlus é utilizada diretamente no Arduino e é
responsável por garantir a troca de dados via porta USB, ao passo que a PyMata deve
ser importada no código do programa em Python de controle e possui as classes e
funções necessárias para fazer uso dessa comunicação.
A biblioteca Sympy para Python, por sua vez, é responsável por prover as funções
necessárias para a realização de cálculos simbólicos e equações de cinemática inversa
necessários para determinar o sinal a ser enviado para os servomotores.
Detalhes da utilização e classes e funções relevantes destas bibliotecas estão
disponíveis no Anexo 6A.
6.3. Código
A partir das bibliotecas mencionadas anteriormente, o código foi escrito de acordo com
as necessidades da plataforma, isto é, o movimento coordenado dos servomotores de
deslocamento dos braços e cálculo dos parâmetros por cinemática inversa. Detalhes de
funções do código e o próprio código estão disponíveis nos anexos 6B e 6C.
56
7. TESTES COM SERVOMOTORES
7.1. Escopo
Para assegurar o funcionamento do robô, foram efetuados alguns testes para verificar
o funcionamento dos servomotores Futaba S3302. É necessário checar se a operação
destes é condizente com os dados do fabricante (Anexo 3C), bem como analisar o
comportamento dos mesmos de acordo com os valores de entrada de forma a registrar
e, caso possível, corrigir possíveis erros de posição.
De forma a verificar tais características, um procedimento de verificação das posições
obtidas por um modelo S3302 a partir de comandos enviados a ele foi efetuado.
Primeiramente, checa-se a capacidade do servomotor de operar com incrementos de 1
microssegundo consecutivos. Em seguida, registram-se as posiçoes obtidas pelo
atuador a partir de diversos inputs e compara-se os resultados com seus valores
teóricos. Finalmente, verifica-se a consistência do servomotor fazendo com que o
mesmo movimente-se para a mesma posição de diferentes pontos de partida.
7.2. Descrição da Bancada experimental
A bancada utilizada para tal experimento consiste em uma mesa plana na qual o
servomotor, montado com um braço com ponteiro em seu eixo, é disposto para análise.
Uma folha quadriculada (quadrados de 5mm de lado), com marcações da posição do
servo e seu eixo, é posicionada sob o servomotor para marcar a posição da extremidade
do braço e determinar o ângulo obtido pelo atuador. Para controlar o atuador, utiliza-se
a unidade de controle da plataforma composta pela placa Arduino em conjunto com o
Raspberry Pi (Figura 7.1, 7.2, 7.3 e 7.4).
57
Figura 7.1: Esquema de teste do servomotor.
Figura 7.2: Servomotor posicionado com ponteiro.
58
Figura 7.3: Folha de marcações com posição do servomotor.
Figura 7.4: Configuração do Arduino, Raspberry Pi e circuito.
7.2.1. Servomotor Futaba S3302
Como mencionado em capítulos anteriores, os servomotores utilizados para a
movimentação do manipulador são do modelo Futaba S3302. Estes modelos possuem
um curso total de 180º e faixa de PWM indo de 544 até 2400 microssegundos e uma
faixa de banda morta, isto é, o menor input ao qual o atuador responde, de 1
microssegundo.
Através destes dados, é possível estimar sua resolução teórica através da equação 7.1:
59
180
(2400 − 544)= 0,097 𝑔𝑟𝑎𝑢 (7.1)
É possível, ainda, criar uma equação de representação angular do servo em valores de
PWM utilizando os valores acima, como pode ser observado na equação 7.2:
(2400 − 544
180) × Â𝑛𝑔𝑢𝑙𝑜 + 544 = 𝑃𝑊𝑀(µ𝑠) (7.2)
Tal equação é fundamental para o funcionamento do manipulador dado que a função
de operação do servomotor, embora aceite valores em graus, apenas números inteiros
são aceitos. Desta forma, valores em microssegundos permitem uma maior precisão na
posição dos braços do manipulador, como pode-se observar na equação 7.1.
Naturalmente, o valor obtido pela equação 7.2 deve ser aproximado para um número
inteiro para que possa ser aceito pelo programa de comando do manipulador.
7.2.2. Braço
O braço utilizado para a marcação das posições do servo possui de (81 ± 0,5) 𝑚𝑚 de
comprimento partindo do eixo de rotação do atuador e é dotado de um ponteiro
perpendicular de (56 ± 0,5) 𝑚𝑚 de comprimento, partindo do braço, cuja extremidade
fica próxima ao papel para marcar as posições obtidas com os comandos.
7.2.3. Recursos de leitura de dados
Para medir as dimensões do braço, ponteiro e as marcações de referência do ponto de
fixação do servomotor, utilizou-se uma régua convencional de 30 cm, ao passo que as
medidas angulares foram tomadas com o auxílio de um transferidor de arco de 180º
(Figura 7.5).
Resolução da régua: 1 mm (Incerteza de 0,5 mm)
Resolução do transferidor: 1º (Incerteza de 0,5º)
60
Figura 7.5: Transferidor utilizado para medição.
7.3. Procedimento
Inicialmente posiciona-se o servomotor na área demarcada com as dimensões de sua
base, observada na figura 7.3. O servomotor deve ser disposto com seu eixo próximo
da parte inferior do papel como na figura 7.2.
Em seguida, a agulha é posicionada na posição de 0 graus e o ponto marcado pela
agulha é utilziado como referência. Testes preliminares são feitos após a marcação,
movendo o ponteiro e o retornando para a posição zero a partir de diversas posições,
para garantir que a posição de referência seja consistente. Depois disso, realiza-se o
experimento para as posiçoes de 20, 40, 60, 80, 90, 120, 140 e 160 graus em sequência,
tomando duas medições para cada posição.
O segundo teste consiste em realizar uma checagem do funcionamento da entrada em
valores em microssegundos, fazendo incrementos de 1 microssegundo ao sinal PWM
em intervalos de 0.01s, até que o servo atinja a posição de 20 graus.
O servomotor Futaba S3302, cujo modelo é a referência para os atuadores de
movimento do braço, apresentou boa precisão e acurácia aceitável, como pode se
observar na tabela 7.1. Efeitos de histerese também não foram observados ao testar as
mesmas posições de diferentes pontos de partida e direções.
61
7.4. Resultados do teste
O servomotor apresentou um desempenho satisfatório, com marcações próximas às
reais, como é observardo nas tabelas 7.1 e 7.2:
Entrada [grau] Medição 1 +- 0,5 [grau] Medição 2 +- 0,5 [grau]
20 21,0 21,0
40 42,0 42,0
60 64,0 63,0
80 84,0 84,0
90 94,0 94,0
100 104,0 106,0
120 124,0 125,0
140 143,0 145,0
160 163,0 164,0
Tabela 7.1: Medição das posições
Entrada [grau] Média +- 0,7 [grau]
20 21,0
40 42,0
60 63,5
80 84,0
90 94,0
100 105,0
120 124,5
140 144,0
160 163,5
Erro médio [grau] 4 +- 2
Tabela 7.2: Média das medições
As discrepâncias em relação ao valor de entrada podem ser justificadas pelas
imprecisões das medições, dada a metodologia utilizada, e das próprias imprecisões do
funcionamento do servomotor. Como forma de corrigir esta diferença de resultados, cria-
se o gráfico 7.1 com os dados da tabela 7.2:
62
E cria-se uma linha de tendência polinomial do segundo grau para criar a equação 7.2
que representa a relação entre o valor de entrada e o de saída:
𝑦 = −0,0004𝑥2 + 1,0985𝑥 − 0,95 (7.2)
Onde x e y na equação 7.2 representam o valor de entrada e saída respectivamente.
De forma a obter a equação que nos dá o input necessário para a posição desejada,
utiliza-se o gráfico 7.2 cujos eixos são invertidos em relação ao gráfico anterior:
Novamente, cria-se uma linha de tendência para obter a equação 7.3:
𝑥 = 0,0004𝑦 + 0,9039𝑦 + 1,012 (7.3)
Onde x representa a entrada necessária para a posição angular y desejada.
y = -0,0004x2 + 1,0985x - 0,95
0
20
40
60
80
100
120
140
160
180
0 20 40 60 80 100 120 140 160 180
Méd
ia [
grau
]
Entrada [grau]
Gráfico 7.1: Entrada x Média
y = 0,0004x2 + 0,9039x + 1,012
0
20
40
60
80
100
120
140
160
180
0 20 40 60 80 100 120 140 160 180
Entr
ada
[gra
u]
Média [grau]
Gráfico 7.2: Média x Entrada
63
Unindo as equações 7.3 e 7.1 no código do programa, pode-se criar uma função de
correção para a posição do servomotor, aumentando sua acurácia.
Em relação ao teste de incrementos unitários, o servomotor apresentou resultados
satisfatórios, atingindo o mesmo ponto de 20 graus medido sem problemas.
Considerando a utilização à qual este atuador é destinado, considera-se que os
resultados são aceitáveis para sua implementação no projeto.
O servomotor TowerPro SG90, por sua vez, não apresentou problemas em seu
funcionamento, atuando de forma satisfatória com os inputs enviados pela unidade de
controle.
64
8. RESULTADOS E CONCLUSÕES
8.1. Simulação de operação
Para verificar o funcionamento do programa de operação do manipulador, uma versão
adaptada do código, presente no Anexo 6C foi utilizada para demonstrar virtualmente
os resultados obtidos pelos métodos de transformação de inputs, checagem de limites
e movimentação aplicados.
Para tal, o programa foi alterado de forma a retornar todos os pontos obtidos para cada
incremento unitário de sinal PWM utilizado nos servomotores, realizando uma
tranformação inversa dos valores de sinal PWM para valores em graus e, em seguida,
valores em graus para milímetros.
Para efetuar tal simulação, o interpretador do Python (IDLE) deve ser aberto
inicialmente. Em seguida o programa de simulação deve ser aberto e executado
pressionando a tecla F5 do teclado. Ao ser executado, o programa estará pronto para
receber comandos do operador que devem vir na forma das funções de letras
disponibilizadas na pelo programa. Para iniciar a simulação de uma letra, o usuário deve
escrever a função da letra desejada (write_A, write_B, write_C, ...) e os parâmetros
necessários para tal função, isto é, tamanho do lado do quadrado da letra, ângulo de
inclinação e posição. O programa irá, então, gerar uma série de pares de coordenadas
indicando todas as posições resultantes dos incrementos unitários efetuados nos
servomotores. Tais coordenadas devem ser salvas em um arquivo .txt e, em seguida,
abertas com o software Microsoft Excel para que possam ser utilizadas na geração de
um gráfico que simboliza a letra a ser desenhada.
A simulação se deu através da execução do programa pelo interpretador do Python e
da utiização de suas funções de escrita. Neste caso, foram utilizadas as funções de
escrita para as letras A e C, com entradas de 10 mm, 0º e posição (10,10) para a letra
A (write_A(1,0,(10,10))) e 20 mm, 10º e posição (15,15) para a letra C
(write_C(2,10,(15,15))). Utilizando as informações provenientes dos outputs de cada
simulação (Anexo 6C), gráficos exibindo os pontos obtidos são gerados pelo software
Microsoft Excel para cada letra, exibindo o perfil obtido da letra.
65
Pode-se observar que, em função do fato de que os servomotores não possuem um
controle direto de velocidade, irregularidades podem ser encontradas nos formatos das
letras nos Gráficos 8.1 e 8.2, como na ponta inferior da letra C. Entretanto, tais erros
eram esperados considerando a natureza do manipulador e, portanto, são considerados
aceitáveis para o objetivo deste trabalho.
8.2. Conclusões
A unidade de controle mostrou-se mais do que adequada para sua utilização no controle
do dispositivo de escrita de 3 graus de liberdade, baseados no uso de servomotores.
0
5
10
15
20
25
30
35
40
45
50
300 320 340 360 380 400 420
Y[m
m]
X[mm]
Gráfico 8.1: Letra A (10mm - 0 grau - (10,10))
0
10
20
30
40
50
60
70
300 320 340 360 380 400 420 440
Y[m
m]
X[mm]
Gráfico 8.2: Letra C (20mm - 10 graus - (15,15))
66
Além disso, a plataforma mostrou-se altamente funcional e com amplas possibilidades
de uso, sendo assim ideal para projetos futuros.
O manipulador, por sua vez, apresentou certas limitações quanto sua precisão, sendo
prejudicado pela ausência de controle de velocidade e inconsistência dos servomotores.
Uma possível solução para tal problema encontra-se na utilização de servomotores
voltados para fins robóticos, diferente dos servomotores de hobbies como os Futaba e
HITEC.
8.3 Sugestões de Desenvolvimentos Futuros
De forma a tornar o programa da plataforma didática mais intuitivo e amigável para
usuários, o desenvolvimento de uma interfáce gráfica dedicada, facilitando entradas e
leitura de saídas, torna-se desejável para uma versão futura deste projeto.
Adicionalmente, uma análise das cargas envolvidas no dispositivo de escrita é desejável
para a comprovação do funcionamento do mesmo, de forma a certificar que a caneta
consiga escrever na superfície do papel.
Algumas características dos elos, ocasionadas pela assimetria dos perfis L utilizados,
como produto de inércia e possíveis deflexões laterias e torções, não foram analisadas,
podendo se mostrar prejudicias para o funcionamento do sistema. Como uma forma de
eliminar este problema, a substituição dos perfis L por perfis U mostra-se desejável em
virtude de seu perfil simétrico que não apresenta as características mencionadas.
Além disso, pode-se desenvolver, utilizando a unidade de controle já estabelecida, uma
nova plataforma didática com utilização de motores de passo, cuja precisão e controle
de velocidade permitem uma maior capacidade de controle e variedade de movimentos,
possibilitando rotinas de escrita e desenho mais complexas. Também seria possível
criar o modelo cinemático completo do manipulador, diferentemente daquele utilizando
servomotores cujas velocidades não podem ser controladas pelo operador, permitindo
uma compreensão mais completa do funcionamento do dispositivo.
67
Referências Bibliográficas
ARDUINO, Arduino – Compare. Disponível em:
https://www.arduino.cc/en/products/compare. Acesso em: 20 fev. 2019.
BAKELITSUL, Pés niveladores – NV-A4-30 – PÉ NIVELADOR COM BASE RÍGIDA
30MM – BakelitSul. Disponível em: https://www.bakelitsul.com.br/produtos/pes-
niveladores/nv-a4-30-pe-nivelador-com-base-rigida-30mm/691?filtro=. Acesso em: 22
fev. 2019.
CRANDALL, S. H, ARCHER, R. R., COOK, N. H., DAHL, N. C., LARDNER, T. J.,
MCCLINTOCK, F. A., RABINOWICZ, E., REICHENBACH, G. S., An Introduction to the
Mechanics of Solids, 2ª ed., McGraw-Hill, 1978.
FILIPEFLOP COMPONENTES ELETRÔNICOS, Kit Raspberry Pi Start (case oficial) –
FilipeFlop. Disponível em: https://www.filipeflop.com/produto/kit-raspberry-pi-start/.
Acesso em: 20 fev. 2019.
GUTENKUNST FEDERN, Molas de Compressão D-011X – Gutenkunst Federn –
Sempre a mola certa. Disponível em:
https://www.federnshop.com/pt/produtos/molas_de_compress%C3%A3o/d-011x.html.
Acesso em: 22 fev. 2019.
HENKEL LTDA., Loctite Industrial Adesão. Disponível em:
http://www.loctiteindustrial.com.br/index.php?categoria=adesao. Acesso em: 20 fev.
2019.
HITEC RCD USA, Analog Sport Servos. Disponível em:
https://hitecrcd.com/products/servos/sport-servos/analog-sport-servos. Acesso em: 20
fev. 2019.
HUDEDMANI, M. G., UMAYAL, R. M., KABBERALLI, S. K., HITTALAMANI, R.,
Programmable Logic Controller (PLC) in Automation, Advanced Journal of Graduate
Research, Vol.2, Issue 1, pp. 37-45, 2017.
LEGO, 31313 MINDSTORMS EV3 – Products – Mindstorms LEGO.com. Disponível em:
https://www.lego.com/en-us/mindstorms/products/mindstorms-ev3-31313. Acesso em:
20 fev. 2019.
MODELIX ROBOTICS, KITS EDUCACIONAIS – KITS DE ROBÓTICA EDUCACIONAL.
Disponível em: https://www.modelix.com.br/kits-educacionais-kits-de-robotica. Acesso
em: 20 fev. 2019.
RASPBERRY PI FOUNDATION, Raspberry Pi 3: Specs, benchmarks & testing – The
MagPi Magazine. Disponível em: https://www.raspberrypi.org/magpi/raspberry-pi-3-
specs-benchmarks/. Acesso em: 20 fev. 2019.
ROBOCORE TECNOLOGIA LTDA., Kit Iniciante V8 para Arduino – Kits Didáticos –
Robo Core. Disponível em: https://www.robocore.net/loja/kits/arduino-kit-
iniciante/blackboard-uno-r3. Acesso em: 20 fev. 2019.
68
ROMANO, V. F, Automação e Robótica – Notas de Aula, 2017.
ROMANO, V. F, Elementos de Máquinas II – Notas de Aula, 2016.
SCHAEFFLER AG, Rolamentos, mancais de deslizamento, acessórios. Disponível em:
https://medias.schaeffler.com/medias/de!hp.ec/1_R*0*F*3?lang=pt .Acesso em: 20 fev.
2019.
SCHNEIDER, CORREIA SINCRONIZADORA PASSO 3M. Disponível em:
http://correias.com.br/download/correia_sincronizadora_3m.pdf. Acesso em: 20 fev.
2019.
SERVODATABASE, Futaba S3302 Servo Specifications and Reviews. Disponível em:
https://servodatabase.com/servo/futaba/s3302. Acesso em: 20 fev. 2019.
SERVODATABASE, TowerPro SG90 Servo Specifications and Reviews. Disponível em:
https://servodatabase.com/servo/towerpro/sg90. Acesso em: 20 fev. 2019.
SYMPY DEVELOPMENT TEAM, SymPy. Disponível em:
https://www.sympy.org/pt/index.html. Acesso em: 20 fev. 2019.
VÁSÁRHELYI, G., VIRÁGH, C., SOMORJAI, G., NEPUSZ, T., EIBEN, A. E., VICSEK,
T., Optimized flocking of autonomous drones in confined environments, Vol.3, Issue 20,
eaat3536, 2018.
WSKITS, Edison Robot, Kit Robótica Software Programação Fácil, Robô Controlável
Compatível c/ Lego. Disponível em: https://www.wskits.com.br/meet-edison-robot-brasil.
Acesso em: 20 fev. 2019.
YORINKS, A., MrYsLab/pymata-aio – This is the second generation PyMata client.
Disponível em: https://github.com/MrYsLab/pymata-aio. Acesso em: 20 fev. 2019.
69
ANEXOS
ANEXO 3A
Especificações técnicas do Arduino Uno (ARDUINO, 2019)
Processador ATPmega328P
Tensão de Operação/Entrada 5V/5-12V
Velocidade de CPU 16MHz
Pinos Analógicos
(Input/Output)
6/0
Pinos Digitais (IO/PWM) 14/6
EEPROM 1kB
SRAM 2kB
Flash 32kB
USB Regular
UART 1
ANEXO 3B
Especificações técnicas do Raspberry Pi 3 Modelo B (RASPBERRY PI
FOUNDATION, 2019)
• CPU Quad Core 1.2GHz Broadcom BCM2837 64bit.
• 1GB RAM.
• BCM43438 wireless LAN and Bluetooth Low Energy (BLE) on board.
• 100 Base Ethernet.
• 40 pinos GPIO.
• 4 portas USB.
• Output estéreo 4 polos e porta de vídeo composta.
• HDMI Full size.
• Porta de câmera CSI para câmera Raspberry Pi.
• Porta de display DSI para tela de toque Raspberry Pi.
• Porta Micro SD para carregamento de sistema operacional e armazenamento de
dados.
• Entrada de energia Micro USB para correntes de até 2.5A.
70
ANEXO 3C
Servomotores
Servomotores são mecanismos de circuito fechado cujo funcionamento permite
rotações ou posicionamentos específicos para um componente. Estes são fundamentais
para a operação de braços robóticos, aeromodelos e VANTs. Dependendo do modelo,
eles podem ser controlados diretamente pela placa Arduino ou com auxílio de um Shield.
Seu funcionamento consiste no movimento angular de seu rotor até uma determinada
posição, especificada através do sinal enviado pelo sistema responsável pelo seu
controle. Tal sinal pode ser simplesmente uma entrada de potência variável, isto é, o
valor da voltagem de entrada determina a posição do rotor, ou um sinal do tipo pulse
width modulation (PWM), que funciona acionando um sinal de potência fixa em
intervalos de tempos variáveis que especificam a posição desejada.
No contexto deste projeto, servomotores de modelo Futaba S3302 foram escolhidos
como os atuadores responsáveis pela rotação dos braços por prover torque suficiente
para tal função. Eles funcionam numa faixa de voltagem de 4.8 a 6V e utilizam sinal de
entrada PWM. Eles possuem curso de 180 graus, com faixa de sinal de PWM de 544 a
2400 microssegundos, provendo uma resolução mínima de aproximadamente 0,097
grau. Embora apresente algumas imprecisões, é possível elaborar uma função de
compensação de erro, como será discutido no capítulo 7. Como mencionado
anteriormente, o movimento de rotação efetuado por estes servomotores é transmitido
por um sistema de polias. Estes servomotores requerem uma quantidade de energia
superior ao que a alimentação direta do Arduino pode suportar, portanto, eles são
alimentados de forma independente.
71
Figura C.1: Servomotor Futaba S3302.
Futaba S3302
Comprimento 58.9mm
Largura 29.0mm
Altura 50.0mm
Peso 103.0g
Torque (Stall) 4.8V: 6.41kg.cm
6.0V: 7.99 kg.cm
Velocidade 4.8V: 4.36 rad/s
6.0V: 5.51 rad/s
Curso 180º
Frequência de pulso 50Hz
Faixa de operação 544-2400µs
Largura de banda morta 1µs
Tabela C.1: Especificações do Servomotor Futaba S3302 (Servodatabase)
O mecanismo de escrita, por sua vez, faz uso de um servomotor TowerPro SG90,
apresentando faixa de voltagem, curso e faixa de PWM iguais aos do modelo S3302,
sua principal diferença sendo tamanho e torques menores em relação ao S3302. Em
função destas características, o SG90 requer uma menor quantidade de energia,
podendo ser alimentado diretamente pelo Arduino.
72
Figura C.2: Servomotor Tower Pro SG90 e acessórios.
Tower Pro SG90
Comprimento 23.0mm
Largura 12.2mm
Altura 29.0mm
Peso 9.0g
Torque (Stall) 4.8V: 1.80 kg.cm
Velocidade 4.8V: 8.73 rad/s
Curso 180º
Frequência de pulso 50Hz
Faixa de operação 544-2400µs
Largura de banda morta 1µs
Tabela C.2: Especificações do Servomotor Futaba S3302(Servodatabase)
73
ANEXO 4A
Parâmetros de Denavit-Hartemberg
O método de Denavit-Hartemberg é utilizado para determinar os parâmetros utilzados
para a matriz de transformação da base um elo i para a a base do elo i-1. A definição
dos parâmetros, segundo notas de aula de Automação e Robótica (ROMANO, 2017), é:
Figura H.1: Esquema dos parâmetros de Denavit-Hartemberg
Parâmetro Descrição
𝑎𝑖 Distância entre os eixos 𝑧𝑖−1e 𝑧𝑖 ao longo do eixo 𝑥𝑖.
𝛼𝑖 Ãngulo entre os eixos 𝑧𝑖−1e 𝑧𝑖 ao longo do eixo 𝑥𝑖.
𝑑𝑖 Distância entre os eixos 𝑥𝑖−1e 𝑥𝑖 ao longo do eixo 𝑧𝑖−1.
𝜃𝑖 Ângulo entre os eixos 𝑥𝑖−1e 𝑥𝑖 ao longo do eixo 𝑧𝑖−1.
74
ANEXO 4B
Desenhos
Organização dos desenhos:
75
ANEXO 6A
Bibliotecas
Bibliotecas PyMata e FirmataPlus
As bibliotecas PyMata e FirmataPlus, desenvolvidas por YORINKS (2018), foram
criadas para uso conjunto. Elas permitem o controle da placa Arduino por um programa
em Python presente em outro computador através de comunicação por uma porta serial
que, no caso da plataforma didática discutida neste trabalhom, trata-se de uma porta
USB.
A biblioteca FirmataPlus é uma versão modificada do protocolo Firmata, disponibilizado
junto com o software de programação do Arduino. Ele é o responsável por estabelecer
a comunicação constante entre Arduino e outro dispositivo por USB.
A biblioteca PyMata, por sua vez, possui as classes e funções necessárias para utilizar
a conexão permitida pela FirmataPlus. Dentre elas, utilizam-se:
a) Classe - PyMata 3
A classe PyMata3 é a principal classe da biblioteca PyMata, atribuindo uma placa
Arduino à uma variável, bem como todas as funções integradas à classe. Como o projeto
lida apenas com uma placa, a função detecta automaticamente a porta USB à qual o
Arduino está conectado.
b) Funções - uno.servo_config(pin) e uno.analog_write(pin, value)
Estas duas funções estão atribuídas à classe PyMata 3. A função uno.servo_config,
como o nome indica, define um dos pinos do Arduino como a entrada de sinal de um
servomotor. A função uno.analog_write(), por sua vez, envia um sinal PWM para o pino
desejado. No caso de pinos cuja função foi associada a um servo, esta função aceita
valores tanto em graus (de 0 a 180) quanto valores PWM puros.
Biblioteca SymPy
A biblioteca SymPy, desenvolvida como biblioteca de uso aberto por uma equipe de
mesmo nome, permite que cálculos simbólicos possam ser realizados em um programa
escrito em Python, podendo ser integrada em diversos tipos de aplicações.
As funções utilizadas no programa de controle são:
a) Symbol
76
A função Symbol atribui um símbolo a uma variável, de forma que tal possa ser utilizada
na representação ou cálculo simbólico de uma equação, expressão, operação, etc..
b) nsolve
A função nsolve acha a solução numérica de um sistema de equações não-lineares. Ela
é utilizada para determinar os ângulos dos servomotores nas equações de cinemática
inversa.
ANEXO 6B
Funções relevantes do código
a) calc_angles
Esta função realiza a cinemática inversa de um par de coordenadas no plano xy,
retornando uma lista com os ângulos teta 1 e teta 2, em graus, que os servomotores se
posicionarão para que a caneta esteja na posição descrita pelo par de coordenadas.
Esta função faz uso da função nsolve da biblioteca sympy, que resolve numéricamente
o sistema de equações resultante da associação do par de coordenadas com o
resultado da análise da posição da caneta feito no item 5.2. A função calc_angles é
usada pela função multiple_point_trans, que simplesmente executa a função várias
vezes para múltiplos pontos.
Existe, ainda, a função direct_kin cujo propósito é o de retornar os valores das
coordenadas resultantes dos inputs dos servomotores, visto que não é possível colocar
valores exatos em função da resolução destes atuadores.
b) servo_angle_pwm
Esta função realiza a conversão de um valor em graus para os valores de sinal PWM
equivalentes para os servomotores. Embora seja possível utilizar a função
uno.analog_write com valores em graus, esta só aceita valores inteiros, portanto um
input com valores em PWM (que, neste caso, variam de 544 até 2401), nos dá uma
melhor resolução. Esta função é utilizada pelas funções servo_conv e servo_multi_conv
que convertem um par de parâmetros e uma lista de pares respectivamente.
c) zero_coord
77
A função zero_coord pega os valores dos pontos de uma letra, considerando também
sua rotação, as coordenadas de seu referencial no papel e as coordenadas do ponto
zero do papel em relação à base do robô e retorna as coordenadas de posição em
relação à base. A função letter_coord faz uso desta, convertendo múltiplos pontos de
uma letra.
d) boundary_check e boundary_check2
As funções boundary_check tem o propósito de checar se os pontos de uma letra se
encontram fora da superfície do papel. A primeira forma da função realiza a checagem
das coordenadas desejadas, ao passo que a segunda forma utiliza as coordenadas
resultantes dos inputs dos servos resultantes da cinemática inversa e aproximações
subsequentes.
e) servos_movement_line, servos_movement_free e servo_intervals
Estas são as funções que efetivamente realizam o movimento do braço. A função
servos_movement_free simplesmente executa duas funções uno.analog_write para
deslocar a caneta para o ponto desejado sem uma trajetória específica. A função
servos_movement_line, por sua vez, realiza um deslocamento em linha reta. Para
realizar tal movimento, é necessário que os movimentos angulares dos servomotores
tenham a mesma duração. Como não há uma função que define a velocidade de rotação
dos servomotores, são feitos incrementos unitários ao sinal PWM de cada motor em
intervalos específicos para cada um. Estes intervalos são calculados pela função
servo_intervals, que estabelece estes valores a partir de um tempo de operação total
definido pelo usuário, isso é, o tempo que o braço deve levar para realizar o movimento.
Como padrão, este tempo de operação é definido como 1 segundo.
A função de movimento retilíneo realiza checagens de direção da rotação, isso é, se o
valor inicial é maior que o final e vice e versa. A partir desta checagem, são feitos
acréscimos ou decréscimos unitários no sinal PWM de cada motor nos intervalos
definidos.
Os intervalos, por sua vez, são checados por meio da função time proveniente da
biblioteca de mesmo nome. O programa salva marcas de tempo para cada servomotor
e realiza checagens constantes para determinar o tempo decorrido. Quando uma das
checagens retorna um intervalo de tempo igual ou maior ao intervalo de tempo de um
dos motores, o sinal é alterado e uma nova marca de tempo é associada ao servomotor.
Este processo é repetido até os valores alvos dos sinais serem atingidos.
78
f) reset_servo
Esta função serve apenas para retornar os braços à posição inicial de teta1=0 e
teta2=45º.
g) pen_active
Esta função envia sinal para o servo da caneta, movendo-a para cima ou para baixo.
h) Funções write
As funções write (write_A, write_B, write_C, etc.) são as funções que realizam todos os
passos necessários para escrever uma letra. Primeiramente, o usuário deve entrar com
os valores de posição, ângulo e tamanho da letra na função. Em seguida, a função
letter_coord é utilizada, seguida pela função boundary_check para realizar a checagem
de limites inicial. Depois disso, as funções multiple_point_trans e servo_multi_conv são
executadas para criar uma lista de pares de parâmetros para os servomotores,
parâmetros estes que são, em seguida, convertidos e avaliados pela função
boundary_check2 para uma nova checagem de limites. Caso a checagem retorne
negativa, a função retorna uma mensagem de erro e encerra a execução. Caso
contrário, uma série de execuções das funções servos_movement_line,
servos_movement_free e pen_active são realizadas de acordo com as necessidades de
cada letra.
ANEXO 6C
Código de operação do dispositivo
from sympy import *
import time
from pymata_aio.pymata3 import PyMata3
from pymata_aio.constants import Constants
uno = PyMata3()
uno.servo_config(3)
uno.servo_config(9)
uno.servo_config(11)
def calc_angles(coord): #função de calculo dos parametros dos servos
para uma posição
x=Symbol('x')
y=Symbol('y')
xc=coord[0]
79
yc=coord[1]
solution=nsolve([300*cos(x)+250*cos(x)*cos(y)-250*sin(x)*sin(y)-
xc,300*sin(x)+250*sin(x)*cos(y)+250*cos(x)*sin(y)-yc],(x,y),(0,1))
solist=[N(solution[0]*180/pi),N(solution[1]*180/pi)]
return solist
def direct_kin(param): #cinemática direta
t1=N(param[0]*pi/180)
t2=N(param[1]*pi/180)
position=[300*cos(t1)+250*cos(t1)*cos(t2)-
250*sin(t1)*sin(t2),300*sin(t1)+250*sin(t1)*cos(t2)+250*cos(t1)*sin(t2
)]
return position
def multiple_points_trans(points): #repete a funçao anterior para
múltilpos pontos
newpoints=[]
for i in points:
p=calc_angles(i)
newpoints.append(p)
return newpoints
def multiple_direct(params): #cinemática direta para múltiplos
parâmetros
direct=[]
for i in params:
p=direct_kin(i)
direct.append(p)
return direct
def servo_angle_pwm(i):
#return N(i+90)
#return N(
return N(1858/180*i+1472)
def reverse_pwm(i):
return N(((i-544)/1856)*180-90)
def servo_conv(angles):
theta=Symbol('Theta')
pwm=[]
for i in angles:
pwm.append(servo_angle_pwm(i))
return pwm
def reverse_conv(pwm):
angles=[]
for i in pwm:
angles.append(reverse_pwm(i))
return angles
def servo_multi_conv(params):
pwm_params=[]
for i in params:
pwm_params.append(servo_conv(i))
return pwm_params
def reverse_multi_conv(params):
angle_params=[]
for i in params:
angle_params.append(reverse_conv(i))
80
return angle_params
def zero_coord(angle,let_coord,pap_coord): #função de cálculo dos pontos
da letra em relaçao ao referencial inercial (posição (0,0) do papel
localizada em (400,25) do referencial (posição do primeiro servo))
let_mat=Matrix([let_coord[0],let_coord[1],0,1])
pap_mat=[pap_coord[0]+400,pap_coord[1]+25]
ang_rad=N(angle*pi/180)
ang_mat=Matrix([[cos(ang_rad),-
sin(ang_rad),0,0],[sin(ang_rad),cos(ang_rad),0,0],[0,0,1,0],[0,0,0,1]]
)
let_mat2=ang_mat*let_mat
final_mat=[let_mat2[0]+pap_mat[0],let_mat2[1]+pap_mat[1]]
return final_mat
def letter_coord(angle,position,letter): #função de cálculo dos pontos
de uma letra
points=letter
newcoords=[]
for i in points:
p=zero_coord(angle,i,position)
newcoords.append(p)
return newcoords
def boundary_check(angle,points,position): #função de checagem de
limites do papel
ang_rad=N(angle*pi/180)
ang_mat=Matrix([[cos(ang_rad),-
sin(ang_rad),0,0],[sin(ang_rad),cos(ang_rad),0,0],[0,0,1,0],[0,0,0,1]]
)
for i in points:
point_mat=Matrix([i[0]+position[0],i[1]+position[1],0,1])
check_mat=ang_mat*point_mat
if check_mat[0]<0 or check_mat[0]>105 or check_mat[1]<0 or
check_mat[1]>148:
return False
return True
def boundary_check2(params): #checagem de limites para parametros
arredondados
angles=reverse_multi_conv(params)
print(angles)
points=multiple_direct(angles)
for i in points:
check_mat=[i[0]-400,i[1]-25]
if check_mat[0]<0 or check_mat[0]>105 or check_mat[1]<0 or
check_mat[1]>148:
return False
return True
def int_aprox(num): #função de aproximação do valor dos ângulos
if float(num-int(num))>0.5:
return int(num)+1
else:
return int(num)
def round_param(param): #arredonda todos os parâmetros de uma lista de
parâmetros
newparam=[]
for i in param:
p=[int_aprox(i[0]),int_aprox(i[1])]
81
newparam.append(p)
return newparam
def servo_intervals(t,points): #determina os intervalos tempo para cada
servo a partir do tempo de movimento desejado em segundos
delta1=((points[0][0]-points[1][0])**2)**0.5
delta2=((points[0][1]-points[1][1])**2)**0.5
if delta1!=0 and delta2!=0:
return [float(t/delta1),float(t/delta2)]
elif delta1==0 and delta2!=0:
return [float(1),float(t/delta2)]
elif delta1!=0 and delta2==0:
return [float(t/delta1),float(1)]
else:
return [float(1),float(1)]
def servos_movement_free(param): #move a caneta para um ponto sem
trajetória determinada
'''
uno.analog_write(9,param[0])
uno.analog_write(11,param[1])
'''
print ("Theta 1 = " +str(param[0]) +" Theta 2 = "+str(param[1]))
time.sleep(0.1)
return
def servos_movement_line(params,t): #move a caneta numa trajetória reta
print (t)
theta11=params[0][0]
theta21=params[0][1]
theta12=params[1][0]
theta22=params[1][1]
timestamp1=time.time()
timestamp2=time.time()
if theta11<=theta12 and theta21<=theta22:
while theta11<theta12 or theta21<theta22:
check = time.time()
if theta11<theta12:
if check - timestamp1 >=t[0]:
theta11=theta11+1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(9, theta11)
print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21<theta22:
if check-timestamp2>=t[1]:
theta21=theta21+1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(11,theta21)
print ('Theta 2 = '+str(theta21))
timestamp2=check
if theta11>=theta12 and theta21<=theta22:
while theta11>theta12 or theta21<theta22:
check = time.time()
if theta11>theta12:
if check - timestamp1 >=t[0]:
theta11=theta11-1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
82
uno.analog_write(9, theta11)
print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21<theta22:
if check-timestamp2>=t[1]:
theta21=theta21+1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(11,theta21)
print ('Theta 2 = '+str(theta21))
timestamp2=check
if theta11<=theta12 and theta21>=theta22:
while theta11<theta12 or theta21>theta22:
check = time.time()
if theta11<theta12:
if check - timestamp1 >=t[0]:
theta11=theta11+1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(9, theta11)
print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21>theta22:
if check-timestamp2>=t[1]:
theta21=theta21-1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(11,theta21)
print ('Theta 2 = '+str(theta21))
timestamp2=check
if theta11>=theta12 and theta21>=theta22:
while theta11<theta12 or theta21>theta22:
check = time.time()
if theta11>theta12:
if check - timestamp1 >=t[0]:
theta11=theta11-1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(9, theta11)
print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21>theta22:
if check-timestamp2>=t[1]:
theta21=theta21-1
#angles=reverse_conv([theta11,theta21])
#print(direct_kin(angles))
uno.analog_write(11,theta21)
print ('Theta 2 = '+str(theta21))
timestamp2=check
print ("Line finished")
time.sleep(0.1)
return
def pen_active(x): #ativa ou desativa a caneta (INCOMPLETO)
if x == 1:
uno.analog_write(3,120)
print ("Active")
return
else:
uno.analog_write(3,60)
print ("Inactive")
83
return
def line_exec(t,param,p1,p2): #escolhe 2 pares de parametros de uma lista
e move numa trajetoria retilinea
selparam=[param[p1],param[p2]]
time=servo_intervals(t,selparam)
servos_movement_line(selparam,time)
return
def reset_servo():
uno.analog_write(9,90)
uno.analog_write(11,135)
print('Theta 1 = 0')
print('Theta 2 = 45')
return
def write_A(size,angle,position):
points=[[0,0],[float(size*10/2),float(size*10)],[float(size*10),0],[fl
oat(size*10/4),float(size*10/2)],[float(size*10*3/4),float(size*10/2)]
]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
servos_movement_free(param_f[3])
pen_active(1)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_B(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10/2),float(size*10)],[fl
oat(size*10/2),float(size*10/2)],[float(size*10*3/4),float(size*10/2)]
,[float(size*10*3/4),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
84
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
line_exec(1,param_f,4,5)
line_exec(1,param_f,5,0)
pen_active(0)
return
def write_C(size,angle,position):
points=[[float(size*10),float(size*10)],[float(0),float(size*10)],[0,0
],[float(size*10),float(0)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_D(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10*3/4),float(size*10*3/4
)],[float(size*10*3/4),float(size*10/4)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,0)
pen_active(0)
return
def write_E(size,angle,position):
85
points=[[float(size*10*3/4),float(size*10)],[0,float(size*10)],[0,0],[
float(size*10*3/4),0],[0,float(size*10/2)],[float(size*10/2),float(siz
e*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
servos_movement_free(param_f[4])
pen_active(1)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_F(size,angle,position):
points=[[float(size*10*3/4),float(size*10)],[0,float(size*10)],[0,0],[
0,float(size*10/2)],[float(size*10/2),float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
servos_movement_free(param_f[3])
pen_active(1)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_G(size,angle,position):
points=[[float(size*10),float(size*10)],[0,float(size*10)],[0.0],[floa
t(size*10),float(0)],[float(size*10),float(size*10/2)],[float(size*10/
2),float(size*10/2)]]
if not boundary_check(angle,points,position):
86
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_H(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10),float(size*10)],[floa
t(size*10),0],[float(size*10/2),float(size*10/2)],[0,float(size*10/2)]
]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
servos_movement_free(param_f[4])
pen_active(1)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_I(size,angle,position):
points=[[float(size*10/2),0],[float(size*10/2),float(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
87
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
return
def write_J(size,angle,position):
points=[[float(size*10/2),float(size*10)],[float(size*10/2),0],[0,0],[
0,float(size*10/4)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_K(size,angle,position):
points=[[0,float(size*10)],[0,0],[0,float(size*10/2)],[float(size*10/2
),float(size*10)],[float(size*10/2),0],[0,float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
servos_movement_free(param_f[4])
pen_active(1)
88
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_L(size,angle,position):
points=[[0,float(size*10)],[0,0],[0,float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
return
def write_M(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10/2),float(size*10/2)],[
float(size*10),float(size*10)],[float(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_N(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10),0],[float(size*10),fl
oat(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
89
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_O(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10),float(size*10)],[floa
t(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,0)
pen_active(0)
return
def write_P(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10/2),float(size*10)],[fl
oat(size*10/2),float(size*10/2)],[0,float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
90
pen_active(0)
return
def write_Q(size,angle,position):
points=[[float(size*10*3/4),0],[float(size*10*3/4),float(size*10)],[0,
float(size*10)],[0,0],[float(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_R(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10*3/4),float(size*10)],[
float(size*10*3/4),float(size*10/2)],[0,float(size*10/2)],[float(size*
10/2),float(size*10/2)],[float(size*10*3/4),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
servos_movement_free(param_f[5])
pen_active(1)
line_exec(1,param_f,5,6)
pen_active(0)
return
def write_S(size,angle,position):
91
points=[[0,0],[float(size*10),0],[float(size*10),float(size*10/2)],[0,
float(size*10/2)],[0,float(size*10)],[float(size*10),float(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_T(size,angle,position):
points=[[0,float(size*10)],[float(size*10),float(size*10)],[float(size
*10/2),float(size*10)],[float(size*10/2),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_U(size,angle,position):
points=[[0,float(size*10)],[0,0],[float(size*10),0],[float(size*10),fl
oat(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
92
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_V(size,angle,position):
points=[[0,float(size*10)],[float(size*10/2),0],[float(size*10),float(
size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
return
def write_W(size,angle,position):
points=[[0,float(size*10)],[0,0],[float(size*10/2),float(size*10/2)],[
float(size*10),0],[float(size*10),float(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
93
def write_X(size,angle,position):
points=[[0,float(size*10)],[float(size*10),0],[float(size*10),float(si
ze*10)],[0,0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_Y(size,angle,position):
points=[[0,float(size*10)],[float(size*10/2),float(size*10/2)],[float(
size*10),float(size*10)],[float(size*10/2),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
servos_movement_free(param_f[1])
pen_active(1)
line_exec(1,param_f,1,3)
pen_active(0)
return
def write_Z(size,angle,position):
points=[[0,float(size*10)],[float(size*10),float(size*10)],[0,0],[floa
t(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
94
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
reset_servo()
Código de simulação
from sympy import *
import time
'''
from pymata_aio.pymata3 import PyMata3
from pymata_aio.constants import Constants
'''
'''
uno = PyMata3()
uno.servo_config(3)
uno.servo_config(9)
uno.servo_config(11)
'''
def calc_angles(coord): #função de calculo dos parametros dos servos
para uma posição
x=Symbol('x')
y=Symbol('y')
xc=coord[0]
yc=coord[1]
solution=nsolve([300*cos(x)+250*cos(x)*cos(y)-250*sin(x)*sin(y)-
xc,300*sin(x)+250*sin(x)*cos(y)+250*cos(x)*sin(y)-yc],(x,y),(0,1))
solist=[N(solution[0]*180/pi),N(solution[1]*180/pi)]
return solist
def direct_kin(param): #cinemática direta
t1=N(param[0]*pi/180)
t2=N(param[1]*pi/180)
position=[300*cos(t1)+250*cos(t1)*cos(t2)-
250*sin(t1)*sin(t2),300*sin(t1)+250*sin(t1)*cos(t2)+250*cos(t1)*sin(t2
)]
return position
def multiple_points_trans(points): #repete a funçao anterior para
múltilpos pontos
newpoints=[]
for i in points:
p=calc_angles(i)
newpoints.append(p)
return newpoints
95
def multiple_direct(params): #cinemática direta para múltiplos
parâmetros
direct=[]
for i in params:
p=direct_kin(i)
direct.append(p)
return direct
def servo_angle_pwm(i):
#return N(i+90)
#return N(
return N(1858/180*i+1472)
def reverse_pwm(i):
return N(((i-544)/1856)*180-90)
def servo_conv(angles):
theta=Symbol('Theta')
pwm=[]
for i in angles:
pwm.append(servo_angle_pwm(i))
return pwm
def reverse_conv(pwm):
angles=[]
for i in pwm:
angles.append(reverse_pwm(i))
return angles
def servo_multi_conv(params):
pwm_params=[]
for i in params:
pwm_params.append(servo_conv(i))
return pwm_params
def reverse_multi_conv(params):
angle_params=[]
for i in params:
angle_params.append(reverse_conv(i))
return angle_params
def zero_coord(angle,let_coord,pap_coord): #função de cálculo dos
pontos da letra em relaçao ao referencial inercial (posição (0,0) do
papel localizada em (400,25) do referencial (posição do primeiro
servo))
let_mat=Matrix([let_coord[0],let_coord[1],0,1])
pap_mat=[pap_coord[0]+400,pap_coord[1]+25]
ang_rad=N(angle*pi/180)
ang_mat=Matrix([[cos(ang_rad),-
sin(ang_rad),0,0],[sin(ang_rad),cos(ang_rad),0,0],[0,0,1,0],[0,0,0,1]]
)
let_mat2=ang_mat*let_mat
final_mat=[let_mat2[0]+pap_mat[0],let_mat2[1]+pap_mat[1]]
return final_mat
def letter_coord(angle,position,letter): #função de cálculo dos pontos
de uma letra
points=letter
newcoords=[]
for i in points:
96
p=zero_coord(angle,i,position)
newcoords.append(p)
return newcoords
def boundary_check(angle,points,position): #função de checagem de
limites do papel
ang_rad=N(angle*pi/180)
ang_mat=Matrix([[cos(ang_rad),-
sin(ang_rad),0,0],[sin(ang_rad),cos(ang_rad),0,0],[0,0,1,0],[0,0,0,1]]
)
for i in points:
point_mat=Matrix([i[0]+position[0],i[1]+position[1],0,1])
check_mat=ang_mat*point_mat
if check_mat[0]<0 or check_mat[0]>105 or check_mat[1]<0 or
check_mat[1]>148:
return False
return True
def boundary_check2(params): #checagem de limites para parametros
arredondados
angles=reverse_multi_conv(params)
print(angles)
points=multiple_direct(angles)
for i in points:
check_mat=[i[0]-400,i[1]-25]
if check_mat[0]<0 or check_mat[0]>105 or check_mat[1]<0 or
check_mat[1]>148:
return False
return True
def int_aprox(num): #função de aproximação do valor dos ângulos
if float(num-int(num))>0.5:
return int(num)+1
else:
return int(num)
def round_param(param): #arredonda todos os parâmetros de uma lista de
parâmetros
newparam=[]
for i in param:
p=[int_aprox(i[0]),int_aprox(i[1])]
newparam.append(p)
return newparam
def servo_intervals(t,points): #determina os intervalos tempo para
cada servo a partir do tempo de movimento desejado em segundos
delta1=((points[0][0]-points[1][0])**2)**0.5
delta2=((points[0][1]-points[1][1])**2)**0.5
if delta1!=0 and delta2!=0:
return [float(t/delta1),float(t/delta2)]
elif delta1==0 and delta2!=0:
return [float(1),float(t/delta2)]
elif delta1!=0 and delta2==0:
return [float(t/delta1),float(1)]
else:
return [float(1),float(1)]
def servos_movement_free(param): #move a caneta para um ponto sem
trajetória determinada
'''
uno.analog_write(9,param[0])
97
uno.analog_write(11,param[1])
'''
print ("Theta 1 = " +str(param[0]) +" Theta 2 = "+str(param[1]))
time.sleep(0.1)
return
def servos_movement_line(params,t): #move a caneta numa trajetória
reta
print (t)
theta11=params[0][0]
theta21=params[0][1]
theta12=params[1][0]
theta22=params[1][1]
timestamp1=time.time()
timestamp2=time.time()
if theta11<=theta12 and theta21<=theta22:
while theta11<theta12 or theta21<theta22:
check = time.time()
if theta11<theta12:
if check - timestamp1 >=t[0]:
theta11=theta11+1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(9, theta11)
#print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21<theta22:
if check-timestamp2>=t[1]:
theta21=theta21+1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(11,theta21)
#print ('Theta 2 = '+str(theta21))
timestamp2=check
if theta11>=theta12 and theta21<=theta22:
while theta11>theta12 or theta21<theta22:
check = time.time()
if theta11>theta12:
if check - timestamp1 >=t[0]:
theta11=theta11-1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(9, theta11)
#print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21<theta22:
if check-timestamp2>=t[1]:
theta21=theta21+1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(11,theta21)
#print ('Theta 2 = '+str(theta21))
timestamp2=check
if theta11<=theta12 and theta21>=theta22:
while theta11<theta12 or theta21>theta22:
check = time.time()
if theta11<theta12:
if check - timestamp1 >=t[0]:
theta11=theta11+1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
98
#uno.analog_write(9, theta11)
#print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21>theta22:
if check-timestamp2>=t[1]:
theta21=theta21-1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(11,theta21)
#print ('Theta 2 = '+str(theta21))
timestamp2=check
if theta11>=theta12 and theta21>=theta22:
while theta11<theta12 or theta21>theta22:
check = time.time()
if theta11>theta12:
if check - timestamp1 >=t[0]:
theta11=theta11-1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(9, theta11)
#print ('Theta 1 = '+str(theta11))
timestamp1=check
if theta21>theta22:
if check-timestamp2>=t[1]:
theta21=theta21-1
angles=reverse_conv([theta11,theta21])
print(direct_kin(angles))
#uno.analog_write(11,theta21)
#print ('Theta 2 = '+str(theta21))
timestamp2=check
print ("Line finished")
time.sleep(0.1)
return
def pen_active(x): #ativa ou desativa a caneta (INCOMPLETO)
if x == 1:
print ("Active")
return
else:
print ("Inactive")
return
def line_exec(t,param,p1,p2): #escolhe 2 pares de parametros de uma
lista e move numa trajetoria retilinea
selparam=[param[p1],param[p2]]
time=servo_intervals(t,selparam)
servos_movement_line(selparam,time)
return
def reset_servo():
#uno.analog_write(9,90)
#uno.analog_write(11,135)
print('Theta 1 = 0')
print('Theta 2 = 45')
return
def write_A(size,angle,position):
points=[[0,0],[float(size*10/2),float(size*10)],[float(size*10),0],[fl
oat(size*10/4),float(size*10/2)],[float(size*10*3/4),float(size*10/2)]
]
99
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
servos_movement_free(param_f[3])
pen_active(1)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_B(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10/2),float(size*10)],[fl
oat(size*10/2),float(size*10/2)],[float(size*10*3/4),float(size*10/2)]
,[float(size*10*3/4),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
line_exec(1,param_f,4,5)
line_exec(1,param_f,5,0)
pen_active(0)
return
def write_C(size,angle,position):
points=[[float(size*10),float(size*10)],[float(0),float(size*10)],[0,0
],[float(size*10),float(0)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
100
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_D(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10*3/4),float(size*10*3/4
)],[float(size*10*3/4),float(size*10/4)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,0)
pen_active(0)
return
def write_E(size,angle,position):
points=[[float(size*10*3/4),float(size*10)],[0,float(size*10)],[0,0],[
float(size*10*3/4),0],[0,float(size*10/2)],[float(size*10/2),float(siz
e*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
101
pen_active(0)
servos_movement_free(param_f[4])
pen_active(1)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_F(size,angle,position):
points=[[float(size*10*3/4),float(size*10)],[0,float(size*10)],[0,0],[
0,float(size*10/2)],[float(size*10/2),float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
servos_movement_free(param_f[3])
pen_active(1)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_G(size,angle,position):
points=[[float(size*10),float(size*10)],[0,float(size*10)],[0.0],[floa
t(size*10),float(0)],[float(size*10),float(size*10/2)],[float(size*10/
2),float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
line_exec(1,param_f,4,5)
pen_active(0)
return
102
def write_H(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10),float(size*10)],[floa
t(size*10),0],[float(size*10/2),float(size*10/2)],[0,float(size*10/2)]
]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
servos_movement_free(param_f[4])
pen_active(1)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_I(size,angle,position):
points=[[float(size*10/2),0],[float(size*10/2),float(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
return
def write_J(size,angle,position):
points=[[float(size*10/2),float(size*10)],[float(size*10/2),0],[0,0],[
0,float(size*10/4)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
103
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_K(size,angle,position):
points=[[0,float(size*10)],[0,0],[0,float(size*10/2)],[float(size*10/2
),float(size*10)],[float(size*10/2),0],[0,float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
servos_movement_free(param_f[4])
pen_active(1)
line_exec(1,param_f,4,5)
pen_active(0)
return
def write_L(size,angle,position):
points=[[0,float(size*10)],[0,0],[0,float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
104
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
return
def write_M(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10/2),float(size*10/2)],[
float(size*10),float(size*10)],[float(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_N(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10),0],[float(size*10),fl
oat(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_O(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10),float(size*10)],[floa
t(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
105
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,0)
pen_active(0)
return
def write_P(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10/2),float(size*10)],[fl
oat(size*10/2),float(size*10/2)],[0,float(size*10/2)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_Q(size,angle,position):
points=[[float(size*10*3/4),0],[float(size*10*3/4),float(size*10)],[0,
float(size*10)],[0,0],[float(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
106
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_R(size,angle,position):
points=[[0,0],[0,float(size*10)],[float(size*10*3/4),float(size*10)],[
float(size*10*3/4),float(size*10/2)],[0,float(size*10/2)],[float(size*
10/2),float(size*10/2)],[float(size*10*3/4),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
servos_movement_free(param_f[5])
pen_active(1)
line_exec(1,param_f,5,6)
pen_active(0)
return
def write_S(size,angle,position):
points=[[0,0],[float(size*10),0],[float(size*10),float(size*10/2)],[0,
float(size*10/2)],[0,float(size*10)],[float(size*10),float(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
line_exec(1,param_f,4,5)
pen_active(0)
107
return
def write_T(size,angle,position):
points=[[0,float(size*10)],[float(size*10),float(size*10)],[float(size
*10/2),float(size*10)],[float(size*10/2),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_U(size,angle,position):
points=[[0,float(size*10)],[0,0],[float(size*10),0],[float(size*10),fl
oat(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_V(size,angle,position):
points=[[0,float(size*10)],[float(size*10/2),0],[float(size*10),float(
size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
108
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
return
def write_W(size,angle,position):
points=[[0,float(size*10)],[0,0],[float(size*10/2),float(size*10/2)],[
float(size*10),0],[float(size*10),float(size*10)]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
line_exec(1,param_f,3,4)
pen_active(0)
return
def write_X(size,angle,position):
points=[[0,float(size*10)],[float(size*10),0],[float(size*10),float(si
ze*10)],[0,0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
pen_active(0)
servos_movement_free(param_f[2])
pen_active(1)
109
line_exec(1,param_f,2,3)
pen_active(0)
return
def write_Y(size,angle,position):
points=[[0,float(size*10)],[float(size*10/2),float(size*10/2)],[float(
size*10),float(size*10)],[float(size*10/2),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
pen_active(0)
servos_movement_free(param_f[1])
pen_active(1)
line_exec(1,param_f,1,3)
pen_active(0)
return
def write_Z(size,angle,position):
points=[[0,float(size*10)],[float(size*10),float(size*10)],[0,0],[floa
t(size*10),0]]
if not boundary_check(angle,points,position):
print ('Out of bounds')
return
pos=letter_coord(angle,position,points)
param=multiple_points_trans(pos)
print(param)
param1=servo_multi_conv(param)
param_f=round_param(param1)
print (param_f)
if not boundary_check2(param_f):
print ('Out of bounds')
return
servos_movement_free(param_f[0])
pen_active(1)
line_exec(1,param_f,0,1)
line_exec(1,param_f,1,2)
line_exec(1,param_f,2,3)
pen_active(0)
return
reset_servo()
110
Output das simulações
Letra A (10 mm - 0 graus – (10,10))
>>> write_A(1,0,(10,10))
[[-32.2569732663837, 83.5597704689136], [-30.1509563748881,
81.6627208110943], [-31.0253312958303, 80.3575045362044], [-
31.2052986358725, 82.6243001377046], [-30.5971515171451,
81.0227855082583]]
[[1139, 2335], [1161, 2315], [1152, 2301], [1150, 2325], [1156, 2308]]
[[-32.2952586206897, 83.6961206896552], [-30.1616379310345,
81.7564655172414], [-31.0344827586207, 80.3987068965517], [-
31.2284482758621, 82.7262931034483], [-30.6465517241379,
81.0775862068966]]
Theta 1 = 1139 Theta 2 = 2335
Active
[0.045454545454545456, 0.05]
[409.498778770909, 35.7909414403630]
[409.829719780403, 35.5272211116703]
[409.768996895773, 36.2208757242707]
[410.099937905268, 35.9571553955782]
[410.038486897681, 36.6512667817485]
[410.369427907175, 36.3875464530558]
[410.307248004508, 37.0821133796713]
[410.638189014003, 36.8183930509787]
[410.575279446221, 37.5134142836097]
[410.906220455716, 37.2496939549170]
[410.842580454876, 37.9451682578323]
[411.173521464370, 37.6814479291396]
[411.109150264621, 38.3773740653095]
[411.440091274115, 38.1136537366169]
[411.374988111701, 38.8100304677176]
[411.705929121196, 38.5463101390249]
[411.640093234457, 39.2431362254411]
[411.971034243951, 38.9794158967485]
[411.904464873329, 39.6766900975781]
[412.235405882823, 39.4129697688854]
[412.168102270859, 40.1106908419417]
[412.099617745424, 40.8082969928221]
[412.431004671693, 40.5451372150653]
[412.361784396314, 41.2431877499623]
[412.693171322583, 40.9800279722055]
[412.623214546119, 41.6785216451023]
[412.954601472388, 41.4153618673454]
[412.883907445809, 42.1142974309556]
[413.215294372078, 41.8511376531989]
[413.143862348465, 42.5505138589701]
[413.475249274734, 42.2873540812133]
[413.403078509285, 42.9871696793304]
[413.734465435554, 42.7240099015737]
[413.661555185581, 43.4242636409630]
[413.992942111850, 43.1611038632062]
111
[413.919291636785, 43.8617944915384]
[414.250678563055, 43.5986347137818]
[414.176287124451, 44.2997609774760]
[414.507674050720, 44.0366011997193]
[414.432540912252, 44.7381618439465]
[414.763927838521, 44.4750020661898]
[414.688052265991, 45.1769958348763]
Line finished
[0.1111111111111111, 0.07142857142857142]
[415.019439192260, 44.9138360571195]
[415.094868848016, 44.2112817374971]
[415.425362992549, 43.9470016134604]
[415.755409325212, 43.6821624512756]
[415.828753112579, 42.9783641432697]
[416.157900985917, 42.7124091827806]
[416.486598214371, 42.4458974653324]
[416.557848368520, 41.7408632685771]
[416.885641483227, 41.4732403295723]
[417.212981131659, 41.2050629291540]
[417.282129924743, 40.4988009851085]
[417.608559828320, 40.2295169685354]
[417.934533455923, 39.9596808003916]
[418.001573197301, 39.2521992921593]
[418.326631472399, 38.9812611417979]
[418.651230673589, 38.7097731639466]
[418.716153710034, 38.0010803160924]
[419.039831974673, 37.7284950183763]
[419.363048379309, 37.4553622314290]
[419.425847095228, 36.7454663097960]
[419.748137003015, 36.4712408936323]
Line finished
Inactive
Theta 1 = 1150 Theta 2 = 2325
Active
[0.16666666666666666, 0.058823529411764705]
[412.499043280354, 39.8469705132490]
[412.829537424886, 39.5826903892124]
[412.761945681188, 40.2814168863726]
[413.092439825721, 40.0171367623360]
[413.422486158384, 39.7522976001512]
[413.752083733553, 39.4869001586157]
[413.684652809273, 40.1871883572914]
[414.014250384443, 39.9217909157559]
[414.343398257780, 39.6558359552668]
[414.672095486235, 39.3893242378187]
[414.604828407585, 40.0911698504069]
[414.933525636040, 39.8246581329586]
[415.261771277853, 39.5575904221409]
[415.589564392560, 39.2899674831361]
[415.522464177543, 39.9933662079943]
[415.850257292250, 39.7257432689895]
[416.177596940683, 39.4575658685711]
[416.504482184971, 39.1888347751011]
112
[416.437551843339, 39.8937822965855]
[416.764437087628, 39.6250512031156]
[417.090866991205, 39.3557671865425]
[417.023653248447, 40.0617070234759]
[417.350083152024, 39.7924230069029]
Line finished
Inactive
Letra C (20mm – 10 graus – (15,15))
>>> write_C(2,10,(15,15))
[[-25.4088470763364, 75.5446660468391], [-28.3020292420111,
82.1765598129546], [-30.9031534204363, 81.8267586341778], [-
27.8785478062973, 75.1866529846715]]
[[1210, 2252], [1180, 2320], [1153, 2317], [1184, 2248]]
[[-25.4094827586207, 75.6465517241379], [-28.3189655172414,
82.2413793103448], [-30.9375000000000, 81.9504310344828], [-
27.9310344827586, 75.2586206896552]]
Theta 1 = 1210 Theta 2 = 2252
Active
[0.03333333333333333, 0.014705882352941176]
[430.556896644725, 63.7193717542869]
[430.230923017123, 63.9892079224307]
[430.338619146288, 63.2608782896001]
[430.012645518685, 63.5307144577438]
[429.686215615108, 63.7999984743170]
[429.793592255889, 63.0725911211375]
[429.467162352312, 63.3418751377107]
[429.140277108024, 63.6106062311806]
[429.247333952774, 62.8841232417657]
[428.920448708485, 63.1528543352356]
[428.593109060053, 63.4210317356539]
[428.699845802040, 62.6954751914690]
[428.372506153608, 62.9636525918874]
[428.044713038900, 63.2312755308922]
[428.151129372311, 62.5066475107477]
[427.823336257604, 62.7742704497525]
[427.495090615790, 63.0413381605702]
[427.601186235727, 62.3176407406170]
[427.272940593914, 62.5847084514349]
[426.944243365459, 62.8512201688831]
[427.050017967946, 62.1284554226050]
[426.721320739491, 62.3949671400532]
[426.392172866154, 62.6609221005423]
[426.497626148133, 61.9390920987514]
[426.168478274796, 62.2050470592404]
[425.838880699627, 62.4704445007759]
[425.944012358961, 61.7495513116060]
[425.614414783792, 62.0149487531413]
[425.284368451129, 62.2797879153262]
[425.389178186603, 61.5598336042268]
[425.059131853940, 61.8246727664116]
113
[424.728637709408, 62.0889528904483]
[424.833125220728, 61.3699395201792]
[424.502631076196, 61.6342196442159]
[424.171690066701, 61.8979399729085]
[424.275855054499, 61.1798696035336]
[423.944914045004, 61.4435899322263]
[423.613527118735, 61.7067497099831]
[423.717369284564, 60.9896243988642]
[423.385982358294, 61.2527841766209]
[423.054150464716, 61.5153826494558]
[423.157669511055, 60.7992044512471]
[422.825837617476, 61.0618029240821]
[422.493561707329, 61.3238393396176]
[422.596757337583, 60.6086103062599]
[422.264481427435, 60.8706467217955]
[421.931762452731, 61.1321203292643]
[422.034634371231, 60.4178425099787]
[421.701915396527, 60.6793161174475]
[421.368754310547, 60.9402261676948]
[421.471302222553, 60.2269016089770]
[421.138141136574, 60.4878116592242]
[420.804538893867, 60.7481574047100]
[420.906762505566, 60.0357881503247]
[420.573160262860, 60.2961338958103]
[420.239117819239, 60.5559145906110]
[420.341016837748, 59.8445026815858]
[420.006974394127, 60.1042833763865]
[419.672492706666, 60.3634982761979]
[419.774066840030, 59.6530457508174]
[419.439585152569, 59.9122606506287]
[419.104665179599, 60.1709090127674]
[419.205914136797, 59.4614179065675]
[418.870994163827, 59.7200662687062]
[418.535636864936, 59.9781473521123]
[418.199843200966, 60.2356604173507]
[418.301203056986, 59.5277007812802]
[417.965409393015, 59.7852138465186]
[417.629180326056, 60.0421581557823]
[417.730213464568, 59.3351647395017]
[417.393984397609, 59.5921090487653]
[417.057320891000, 59.8484838658763]
[417.158027022532, 59.1424586950109]
[416.821363515923, 59.3988335121219]
[416.484266534247, 59.6546381025342]
[416.584645370263, 58.9495831999349]
[416.247548388587, 59.2053877903472]
[415.910018897670, 59.4606214211484]
[416.010070150572, 58.7565388068862]
[415.672540659655, 59.0117724376874]
[415.334579626560, 59.2664343776012]
[415.434303009689, 58.5633260689613]
[415.096341976594, 58.8179880088750]
[414.757950369623, 59.0720775282627]
114
[414.419129158311, 59.3255938991259]
[414.518953990288, 58.6240350591266]
[414.180132778976, 58.8775514299898]
[413.840882934087, 59.1304939259723]
[413.940378355026, 58.4299141441419]
[413.601128510137, 58.6828566401244]
[413.261451003665, 58.9352245365141]
[413.360616728499, 58.2356258201018]
[413.020939222027, 58.4879937164914]
[412.680835027191, 58.7397862902224]
[412.340305118433, 58.9910028198774]
[411.999350471412, 59.2416425856894]
[411.657972063008, 59.4917048695440]
[411.316170871313, 59.7411889549812]
Line finished
[0.037037037037037035, 0.3333333333333333]
[411.416703612779, 59.0448817967192]
[411.516057593626, 58.3484054674421]
[411.614232529193, 57.6517619626420]
[411.711228138196, 56.9549532782904]
[411.807044142730, 56.2579814108318]
[411.901680268270, 55.5608483571783]
[411.995136243673, 54.8635561147037]
[412.087411801174, 54.1661066812381]
[412.425803408145, 53.9120171618504]
[412.516467709488, 53.2138401151483]
[412.605950099249, 52.5155106040989]
[412.694250321051, 51.8170306295045]
[412.781368121902, 51.1184021925977]
[412.867303252199, 50.4196272950371]
[412.952055465726, 49.7207079389008]
[413.035624519658, 49.0216461266805]
[413.118010174559, 48.3224438612764]
[413.199212194384, 47.6231031459908]
[413.533254638005, 47.3633224511901]
[413.612832589185, 46.6632802390372]
[413.691225487561, 45.9631043307155]
[413.768433108527, 45.2627967323170]
[413.844455230872, 44.5623594503109]
[413.919291636785, 43.8617944915384]
[413.992942111850, 43.1611038632062]
[414.065406445049, 42.4602895728810]
[414.136684428761, 41.7593536284840]
[414.206775858768, 41.0582980382847]
[414.536373433937, 40.7929005967493]
Line finished
[0.03225806451612903, 0.014492753623188406]
[414.933525636040, 39.8246581329586]
[415.261771277853, 39.5575904221409]
[415.194218535729, 40.2604339188121]
[415.522464177543, 39.9933662079943]
[415.850257292250, 39.7257432689895]
[415.782419080199, 40.4295826360087]
115
[416.110212194907, 40.1619596970039]
[416.437551843339, 39.8937822965855]
[416.369428355726, 40.5986155173642]
[416.696768004159, 40.3304381169459]
[417.023653248447, 40.0617070234759]
[416.955244680455, 40.7675320785784]
[417.282129924743, 40.4988009851085]
[417.608559828320, 40.2295169685354]
[417.539866375948, 40.9363318356840]
[417.866296279525, 40.6670478191108]
[418.192269907128, 40.3972116509671]
[418.123291767190, 41.1050143050484]
[418.449265394793, 40.8351781369047]
[418.774781812466, 40.5647905903049]
[418.705519182595, 41.2735790033752]
[419.031035600268, 41.0031914567754]
[419.356093875366, 40.7322533064139]
[419.286546954007, 41.4420254477051]
[419.611605229105, 41.1710872973436]
[419.936204430295, 40.8995993194924]
[419.866373416709, 41.6103531554181]
[420.190972617899, 41.3388651775668]
[420.515111815163, 41.0668281500730]
[420.444996909425, 41.7785616442341]
[420.769136106689, 41.5065246167402]
[421.092814371329, 41.2339393190240]
[421.022415774325, 41.9466504322143]
[421.346094038965, 41.6740651344982]
[421.669310443601, 41.4009323475510]
[421.598628357034, 42.1146190377636]
[421.921844761669, 41.8414862508164]
[422.244598380245, 41.5678067571978]
[422.173633006627, 42.2824669796307]
[422.496386625203, 42.0087874860121]
[422.818676532989, 41.7345620698484]
[422.747428075646, 42.4501937769099]
[423.069717983432, 42.1759683607463]
[423.391543257028, 41.9011978077278]
[423.320011920095, 42.6177989490432]
[423.641837193691, 42.3430283960248]
[423.963196911026, 42.0677134934037]
[423.891382899449, 42.7852820158205]
[424.212742616784, 42.5099671131994]
[424.533635857123, 42.2341086497875]
[424.461539376658, 42.9526424973815]
[424.782432616997, 42.6767840339697]
[425.102858460940, 42.4003828001363]
[425.030479718153, 43.1198799142178]
[425.350905562096, 42.8434786803844]
[425.670863091582, 42.5665354680538]
[425.598202293848, 43.2869937871729]
[425.918159823334, 43.0100505748422]
[426.237648121646, 42.7325661774914]
116
[426.164705477146, 43.4539836374445]
[426.484193775457, 43.1764992400937]
[426.803211927219, 42.8984744527506]
[426.729987644944, 43.6208489865859]
[427.049005796706, 43.3428241992427]
[427.367552887892, 43.0642598184831]
[427.294047177637, 43.7875893565065]
[427.612594268823, 43.5090249757470]
[427.930669386756, 43.2299217996930]
[427.856882459125, 43.9542042694745]
[428.174957577058, 43.6751010934206]
[428.492559810411, 43.3954599217379]
[428.418491876814, 44.1206932481172]
[428.736094110167, 43.8410520764346]
[429.053222548971, 43.5608737103304]
[428.978873821620, 44.2870558154227]
[429.296002260424, 44.0068774493185]
[429.612655996066, 43.7261626915390]
[429.538026687981, 44.4532914947411]
[429.854680423623, 44.1725767369616]
[430.170858548850, 43.8913263917900]
[430.095948873853, 44.6193998097864]
[430.412126999079, 44.3381494646148]
[430.727828608001, 44.0563643378686]
[430.652638780717, 44.7853802846373]
[430.968340389639, 44.5035951578912]
[431.283564577731, 44.2212760569203]
[431.208094813589, 44.9512324437391]
[431.523319001680, 44.6689133427683]
[431.838064865785, 44.3860610764525]
[431.762315381015, 45.1169558119044]
[432.077061245120, 44.8341035455886]
[432.391327883452, 44.5507189243351]
[432.315298895086, 45.2825499143147]
[432.629565533417, 44.9991652930613]
[432.943352045562, 44.7152491288027]
[433.256657532481, 44.4308022349948]
[433.569481096517, 44.1458254266134]
[433.881821841389, 43.8603195201531]
[434.193678872202, 43.5742853336242]
[434.505051295448, 43.2877236865505]
Line finished
Inactive
DATA:30/08/2018
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
Conjunto geral
COTAS
Braço de 3 Graus de Liberdade
Autor: Rafael Huang Cestari
1:5 A
REVISÃOESCALA
mm
0.051 Dec. LINEAR2 Dec.
0.10.5º
Orientador: Prof. Vitor Romano
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-0-0-0
1 2 3
A
A
---
5
PEÇA
1
2
3
MATERIAL
---
QUANTIDADE
1
Pés Bakelitsul NV-A4-30 05803
TIPO
Conjunto 2
Conjunto 1
---
Parafuso M3x5mm
---
4
---
1
Parafuso M8x20mm
8
4
e valor máximo de 180 mm.
4
---
Bucha M8
4
4
Alumínio
Porca M86
1
---
Mesa7
Nota: A dimensão A possui valor mínimo de 167 mm
8
7
692
490
54
6
DETALHE AESCALA 1 : 4
8
Produto educacional do SOLIDWORKS. Somente para fins de instrução.
13
100
60
7
5
8
4164
7
3
9
2 2 5 63
B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
Conjunto 1LINEAR 0.1
0.5º
Orientador: Prof. Vitor Romano
Braço de 3 Graus de Liberdade
B
A
Autor: Rafael Huang Cestari
AANGULAR
A DATA:30/08/2018
0.05
(isométrica 1:5)
ESCALA COTAS
mm
2 Dec. 1 Dec.
REVISÃO
0 Dec. 0.50 Dec. 1º1 Dec.
1:2
CÓD:1-1-0-0
10
11
Polia Servo
Polia Elo 1
---
---
2
1
1---Polia Elo 212
13 M3x10mm s/ Cabeça ---
1
2
3
4
5
67
Elo 1 Alumínio 1
8---Porca M3
Paraf. M3x10mm --- 8
Futaba S3302 --- 2
Paraf. M1.6x10mm --- 8
Correia HTD-216-3M-06
Rolam. FAG6200A------
desenhos.
9 Árvore 2 Alumínio 1
QUANTIDADEPEÇA MATERIALTIPO
8 Subconjunto 1 ---
22
1
Notas: -Fixação dos rolamentos (3) comseus encaixes no elo (1) será feito utilizando adesivo Loctite 496 ou similar.
-Fixação dos rolamentos (3) em suas respectivas árvores (2 e 8) será feito por ajuste incerto auxiliado por adesivoLoctite 496 ou similar.
-Todas as polias (5, 10, 11) utilizam comobase polias de modelo HTD-30M-6F,possuindo diferentes furaçõesrepresentadas em seus respectivos
2
101110 12
460
Produto educacional do SOLIDWORKS. Somente para fins de instrução.
320,28
429,30
460
20,28
16,28
81,18 85,18
129,30
16,
00
381,18
385,18
316,28
R3,0
8 furos
16,
00
25,
50
35,
00
25,
5
R3,0
35,
00
3,3
40,
0
AA BB
Departamento de Engenharia Mecânica
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ANGULARElo 1
LINEAR
mm DATA:30/08/2018Braço de 3 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A1:2
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor RomanoESCALA
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD: 1-1-1-0
CORTE B-BESCALA 1 : 1
10,00
1,0
0
30,10 3,3
2,0
0
Notas: -Ajustar as posições dos furos de 3 mm dediâmetro para a fixação dos servomotoresFutaba S3302.-Ajustar os diâmetros de 30,1 mm e profundidade de 1mm dos rebaixos para acomodar e fixar rolamentos INA/FAG 6200A com adesivo Loctite 480 ou similar.
CORTE A-AESCALA 1 : 1
10,00
30,10 3,3
1,0
0
2,0
0
31
51
2
1
2
3
Base Alumínio 1
1
1
TIPO
M6 x 10mm
Alumínio
PEÇA
Eixo 1
MATERIAL QUANTIDADE
---
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
Subconjunto 1LINEAR
A
0.1
Braço de 3 Graus de Liberdade
Orientador: Prof. Vitor Romano
ANGULAR
1:1
COTAS
A
CC
ESCALA
BB
DATA:30/08/2018
A0.052 Dec.
mm
1 Dec.
REVISÃO Autor: Rafael Huang Cestari
0.5º
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-1-8-0
2
100
60
3
1
0.5º
DATA:30/08/2018
ESCALA
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Braço de 3 Graus de Liberdade
TOLERÂNCIAS GERAIS(mm)
ANGULAR
2:1
Autor: Rafael Huang Cestari
A
Departamento de Engenharia Mecânica
REVISÃO
mm
Orientador: Prof. Vitor RomanoCOTAS
0.052 Dec.
Base1 Dec. LINEAR 0.1
Graduação em Engenharia Mecânica
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-1-8-1
8,8
90,0°
4 furos
6,6
17,0
17,
0
60
,0
AA
Nota: Diâmetro de 14mm deve utilizar como referência o diâmetrode 14mm da Árvore 1 de forma que a mesma possa ser encaixadaneste rebaixo.
CORTE A-A
12,0
14,0
9,0
Graduação em Engenharia Mecânica
DATA:30/08/2018
Departamento de Engenharia Mecânica
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
0.5º
TOLERÂNCIAS GERAIS(mm)
ESCALA
1:1
Autor: Rafael Huang Cestari
A
Departamento de Engenharia Mecânica
REVISÃO
mm
Orientador: Prof. Vitor RomanoCOTAS
0 Dec. 1 Dec. Árvore 10 Dec.
0.10.5º
Orientador: Prof. Vitor RomanoESCALA
1:1
COTAS
mm
REVISÃO
A
Autor: Rafael Huang CestariDATA:30/08/2018
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Braço de 3 Graus de Liberdade
TOLERÂNCIAS GERAIS(mm)
ANGULAR1 Dec. 2 Dec.
1 Dec. LINEAR0.5 Árvore 10.050.05
LINEAR2 Dec.
1º0.1
Graduação em Engenharia Mecânica
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-1-8-2
M6
14
A
8,90
9,90
B
C
C
Notas: -O elemento representado por A é uma mossa que deve ser ajustadapara um parafuso M3 sem cabeça.
-A dimensão B deve ser utilizar comoreferência furo roscado M3 da Polia Elo 1.
-O diâmetro de 9,9 mm deve ser ajustado para fixação de um rolamentoINA/FAG 6200A por meio de adesivo Loctite 496 ou similar.
-O diâmetro de 8,9 mm deve ser ajustado para o furo central vertical da Polia Elo 1.
CORTE C-C
17,
50
46,
15
11,
25
93,
5
10,
00
B
8,90 Notas: -O elemento representado por A é uma mossa que deve ser ajustadapara um parafuso M3 sem cabeça.
-A dimensão B deve utilizar como referênciao furo roscado M3 da Polia Elo 2.
-O diâmetro de 9,9 mm deve ser ajustado para fixação de um rolamento INA/FAG 6200A por meio de adesivo Loctite 496 ou similar.
-O diâmetro de 8,9 mm deve ser ajustado para o furo central vertical da Polia Elo 2.
A
37,
15
9,0
0 1
7,50
9,90
14,0
DATA:30/08/2018
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
2:1
COTAS
Braço de 3 Graus de Liberdade
Autor: Rafael Huang CestariCÓD:1-1-9-0
A
REVISÃOESCALA
mm
0.051 Dec. LINEAR2 Dec.
0.10.5º
Orientador: Prof. Vitor Romano
0 Dec. 0.50 Dec. 1º1 Dec.
Árvore 2
8,00
4 furos M
1.6
90,0°
8,0
0
AA
CORTE A-A
10,
00
32,00
1,0
0
9,00
11,
75
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
CÓD:1-1-10-0
LINEAR
mm DATA:30/08/2018Braço de 3 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A
Polia Servo
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor RomanoESCALA
0 Dec. 0.50 Dec. 1º1 Dec.
2:1
28,6
5
17,50
1,00
7,70
20,0
0
7,80
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
CÓD: 1-1-11-0
LINEAR
mm DATA:30/08/2018Braço de 3 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A
Polia Elo 1
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor RomanoESCALA
0 Dec. 0.50 Dec. 1º1 Dec.
2:1
7,8
0
17,
50
7
,70
3,8
5
M3
20,00
28,65
A
A CORTE A-A
9,00
32,00
28,65
17,
50
7,7
0
3,8
5
M3
20,00
7,8
0
32,00
A
A
Departamento de Engenharia Mecânica
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ESCALA
Polia Elo 2LINEAR
mm DATA:30/08/2018Braço de 3 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A2:1
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor Romano
ANGULAR0 Dec. 0.5
0 Dec. 1º1 Dec.
CÓD: 1-1-12-0
8,0
0
8,00 90,00°
4 furos M3
CORTE A-A
5,0
0
9,00
1,0
0
7,5
0
1
3
2
4
279
55
Autor: Rafael Huang CestariBraço de 3 Graus de Liberdade DATA:30/08/2018
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ESCALA
A
REVISÃOOrientador: Prof. Vitor Romano
mm
COTAS
0.5º
1:2
0.05
Departamento de Engenharia Mecânica
2 Dec. 1 Dec.
Conjunto 2LINEAR 0.1
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-2-0-0
5
6
142
PEÇA TIPO MATERIAL QUANTIDADE
2
1AlumínioElo 2
distância aceitável da superfície de escrita.
6 Fixador da Caneta Alumínio 1
5 Caneta Bic Cristal --- 1
1---Subconjunto 24
2---Porca M3
2---Parafuso M3x10mm
3
Nota: O fixador é preso tanto à caneta quanto à placa domecanismo por meio de adesivo Loctite 496 ou similar. O fixador deve ser posicionado a uma distância de 85mmda parte traseira da caneta de forma a manter uma
1
Produto educacional do SOLIDWORKS. Somente para fins de instrução.
2
R3,
00
22,00
10,
00
DATA:30/08/2018
ESCALA
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ANGULARElo 2
COTAS
Braço de 3 Graus de Liberdade
Autor: Rafael Huang Cestari
1:2 A
REVISÃO
Departamento de Engenharia Mecânica
mm
0.051 Dec. LINEAR2 Dec.
0.10.5º
Orientador: Prof. Vitor Romano
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD: 1-2-1-0
2,00
25,
00
20,
50
253,25
238,25
16,00
12,
50 4 furos
3,30
2 fu
ros
3,30
4,5
0 8,00
24,00
12,
50
8
5
76
49
51
2
4
1
2
39
10
55
---
2
PEÇA TIPO MATERIAL QUANTIDADE
7
1
3
4
5
6 1
8
9
10
Suporte Alumínio 1
Parafuso M2x10mm --- 2
Parafuso M2 (servo) --- 1
Porca M2 --- 2
Guia Alumínio 2
Suporte Caneta Alumínio
1
Mola Gutenkust D-011X --- 2
Elevador Alumínio 1
Servomotor SG90 --- 1
Parafuso M1.6x10mm
Nota: As molas Gutenkust (7) são fixadas à placa da caneta (6) e aoelevador (8) por meio adesivoLoctite 496 ou similar.
DATA:30/08/2018
ESCALA
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
Subconjunto 2
COTAS
Braço de 3 Graus de Liberdade
Autor: Rafael Huang Cestari
1:1 A
REVISÃO
ANGULAR
mm
0.051 Dec. LINEAR2 Dec.
0.10.5º
Orientador: Prof. Vitor Romano
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-2-4-0
23,
0
41,0
2,00
Nota: Os 2 furos devem ser adaptados para fixar o servo-motor SG90
7,4
0
14,45
2 furos
R3,00
5,2
5
37,
00
2,20
30,
90
8,35
33,
05
3,30 2
5,00
37,
75
32,
00
20,05
43,
50
10
,0
12,05
2,20
2 furos
10,
00
2 furos
48,
00
DATA:30/08/2018
Departamento de Engenharia Mecânica
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ANGULARSuporte Guia
COTAS
Braço de 3 Graus de Liberdade
Autor: Rafael Huang Cestari
(isométrica 1:1) A
REVISÃO
mm
0.05
ESCALA
LINEAR2 Dec.
0.10.5º
Orientador: Prof. Vitor Romano
1 Dec. 0 Dec. 0.5
0 Dec. 1º1 Dec.
2:1
CÓD: 1-2-4-1
CORTE B-B
11,
00
13,
00
M2
Departamento de Engenharia Mecânica
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ESCALA
Guia CanetaLINEAR
mm DATA:30/08/2018Braço de 2 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A2:1
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor Romano
ANGULAR0 Dec. 0.5
0 Dec. 1º1 Dec.
CÓD: 1-2-4-5
3,90
45,
0
B
B
CORTE A-A
25,5
CORTE B-B
18,
0
7,00
18,50 8,
10
12,75
3,0
0
11,
00
2 furos 4,00
B
B
AA
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
Departamento de Engenharia Mecânica
CÓD:1-2-4-6
LINEAR
mm DATA:30/08/2018Braço de 3 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A(isométrica 2:1)
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor RomanoESCALA
0 Dec. 0.50 Dec. 1º1 Dec.
5:1
Suporte Caneta
CORTE A-A R0,85 3,00
2,00
14,50
7,75
2,7
5 5,5
0
4,10
17,5
2 furos
6,0
0
AA
Braço de 3 Graus de Liberdade
Orientador: Prof. Vitor RomanoESCALA
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
DATA:30/08/2018
ANGULAR
5:1
Autor: Rafael Huang Cestari
A
Departamento de Engenharia Mecânica
REVISÃO
mm
TOLERÂNCIAS GERAIS(mm)
COTAS
0.052 Dec.
Elevador1 Dec. LINEAR 0.1
0.5º
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD: 1-2-4-8
Departamento de Engenharia Mecânica
A A
B B
C C
D D
E E
F F
8
8
7
7
6
6
5
5
4
4
3
3
2
2
1
1
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Graduação em Engenharia Mecânica
TOLERÂNCIAS GERAIS(mm)
ESCALA
FixadorLINEAR
mm DATA:30/08/2018Braço de 3 Graus de Liberdade
COTAS Autor: Rafael Huang Cestari
A5:1
REVISÃO
0.052 Dec. 1 Dec. 0.1
0.5º
Orientador: Prof. Vitor Romano
ANGULAR0 Dec. 0.5
0 Dec. 1º1 Dec.
CÓD: 1-2-6-0
12,
0
14,0
12,0
10,
0
A
A CORTE A-A
8,0
Graduação em Engenharia Mecânica
1
Departamento de Engenharia Mecânica
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
2
TOLERÂNCIAS GERAIS(mm)
15
2
3
5 3
46
4
0.052 Dec.
Mesa1 Dec. LINEAR 0.1
0.5º
Orientador: Prof. Vitor RomanoESCALA
1:4
COTAS
mm
REVISÃO
A
Autor: Rafael Huang CestariBraço de 3 Graus de Liberdade DATA:30/08/2018
ANGULAR
A A
B B
C C
D D
E E
F F
8
8
7
7
6
0 Dec. 0.50 Dec. 1º1 Dec.
CÓD:1-7-0-0
Nota: Os furos na extremidade esquerda da peça,associados às dimensões horizontais de 48, 65 e 82 mmdevem utilizar como base os furos da base do Subconjunto 1
Espessura da peça: 2 mm
490
20
82
20
170
20
48
20
65
440
75
58
130
20
150
130
20
8,8
12
furo
s
20 20
20