robô apontador de fonte luminosa - páginas...
TRANSCRIPT
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ DEPARTAMENTO ACADÊMICO DE INFORMÁTICA
CURSO DE ENGENHARIA DE COMPUTAÇÃO
Juan Pietro Cucolo Marçula Laudelino Adão Junior
Sergio Augusto Massami Nakanishi Vinicius Silva Mazzola
Light Tracker
Robô Apontador de Fonte Luminosa
CURITIBA 2012
2
Juan Pietro Cucolo Marçula Laudelino Adão Junior
Sergio Augusto Massami Nakanishi Vinicius Silva Mazzola
Light Tracker
Robô Apontador de Fonte Luminosa
Monografia apresentada à Disciplina Oficina de Integração II, do Curso Superior de Engenharia de Computação da Universidade Tecnológica Federal do Paraná. Orientador: Juliano Mourão Vieira
CURITIBA 2012
3
LICENCIAMENTO
Este trabalho está licenciado por Juan Pietro Cuculo Marçula, Laudelino
Adão Junior, Sergio Augusto Massami Nakanishi e Vinicius Silva Mazzola uma
Licença Creative Commons Atribuição – Obras Derivadas Proibidas 3.0 Brasil.
Para ver uma cópia desta licença, visite
http://creativecommons.org/licenses/by-nc-sa/3.0/br/ ou envie uma carta para
Creative Commons, 171 Second Street, Suite 300, San Francisco, California.
4
RESUMO
O rápido crescimento da população mundial, resultando em um maior consumo
de energia, aliado ao fato da natureza limitada dos combustíveis fósseis e à
poluição que a queima desses combustíveis geram, questiona o atual modelo
energético. A conseqüência disso é o aumento da procura por fontes limpas de
energia, e uma boa alternativa para o futuro é a energia solar. O projeto
vislumbra a construção de um dispositivo de baixo custo que possui a função
de fazer com que haja uma maior captação de luz solar para que haja uma
maior geração de energia elétrica.
O projeto consiste no acoplamento de sensores de luz (LRD) (que estão
ligados ao Arduino) na placa solar, que têm seus valores de resistência lidos
pelo Arduino, que transfere essa informação ao software. Ele possui a função
de receber esses valores e fazer o cálculo adequado para o controle do servo
motor. Ou seja, o software fará os cálculos a partir dos valores lidos pelo
Arduino e a partir deles, irá determinar a direção que o servo motor girará para
a obtenção de uma maior captação de luz. A placa solar está dentro de um
sistema físico composto pela estrutura que é tida como suporte e pelo servo
motor.
.
Palavras Chave: Light Tracker, Arduino, LDR,Servomotor, Robô, Apontador de foco luminoso, Robótica;
5
ABSTRACT
The fast growth of world population, resulting in higher power
consumption, coupled with the fact of the limited nature of fossil fuels and the
pollution that burning these fuels generate, questions the current energy
model. The consequence is an increased demand for clean sources of energy,
and a good alternative for the future is the solar energy. The project envisages
the construction of an inexpensive device that has the function of
getting a greater capture of sunlight, so there is a higher power generation.
The project consists in coupling light sensors (LRD) (which are
connected to Arduino) in the solar panel, that have their resistance values read
by Arduino, which transfers this information to the software. It has the
function of receiving these values, making the appropriate calculation to control
the servo motor. That is, the software will do the calculations from the values
read by the Arduino and from them, it will determine which direction
the servo motor must rotates to obtain a greater light gathering. The solar
panel is within a physical system composed of the structure that is seen
as support and the servo motor.
Key Words: Light Tracker, Arduino, LDR, Robots, Servomotor.
6
LISTA DE FIGURAS
1 Arduino 15
2 O LDR 16
3 Constituição do LDR 16
4 Servomotor Hextronik HXT900 17
5 Circuito divisor de tensão 18
6 Diagrama de blocos 21
7 Possíveis posições do servomotor 24
8 Posições dos LDR’s 25
9 Circuito divisor de tensão para o sistema de sensoriamento 26
10 Ambiente de desenvolvimento Arduino 27
11 Modelo 3D em visão geral 29
12 Haste em destaque no modelo 3D(a) e em acrílico(b) 30
13 Base em destaque no modelo 3D(a) e em acrílico(b) 31
14 Esferas em destaque no modelo 3D 32
15 Arduino e LDRs em destaque no modelo 3D 32
16 Servomotores em destaque no modelo 3D 33
17 Espelho de mesa 34
18 Chapas de plástico 34
19 Chapas de foam 35
7
LISTA DE TABELAS
1 Classificação de robôs segundo a JIRA 12
2 Classificação robôs por coordenadas 14
3 Componentes, quantidade e preço 36
4 Peças do esqueleto 36
8
Sumário 1. INTRODUÇÃO ............................................................................................. 9
1.1. Objetivos .............................................................................................. 10
1.2. Metodologia ......................................................................................... 11
2. FUNDAMENTAÇÃO TEÓRICA ................................................................. 12 2.1. Robôs e Robótica ................................................................................ 12
2.1.1. Vantagens e desvantagens do uso de robôs ................................... 13 2.1.2. Componentes de Robôs .................................................................. 13 2.1.3. Orientação e movimentação de um Robô ....................................... 14 2.1.4. Características de Robôs ................................................................. 14
2.2. Arduino ................................................................................................. 15
2.3. LDR ...................................................................................................... 16
2.4. Servomotor .......................................................................................... 17
2.4.1. Arduino e Servomotor .................................................................... 18 2.5. Divisor de Tensão ................................................................................ 18
3. DESENVOLVIMENTO DO PROJETO ....................................................... 21 3.1. Sistema proposto ................................................................................. 22
3.2. Hardware ............................................................................................... 22
3.2.1. Processador/Controlador ................................................................ 23 3.2.2. Atuadores ......................................................................................... 23 3.2.3. End Effector ..................................................................................... 24 3.2.4. Sensores .......................................................................................... 24
3.3. Software ................................................................................................. 26
3.4. Esqueleto ............................................................................................... 29
3.4.1. Materiais ........................................................................................... 34 3.5. Custos .................................................................................................... 35
3.6 Problemas, erros e possíveis soluções .................................................. 37
3.6.1 Limitação de movimentação ............................................................. 37 3.6.2 Detecção da não necessidade de movimento em condições de baixíssima luminosidade ............................................................................ 37
5. CONCLUSÕES .......................................................................................... 38 6. REFERÊNCIAS ............................................................................................. 40 APÊNDICE A – Diagrama de classes do software ....................................... 41 APÊNDICE B – Software desenvolvido ......................................................... 42 APÊNDICE C – Diagrama de Gantt ................................................................ 49
9
1. INTRODUÇÃO
A decisão em desenvolver esse trabalho levou em consideração a atual
situação energética do planeta. Nos dias de hoje, há uma busca intensa por
fontes renováveis de energia, já que ultimamente as fontes não-renováveis têm
poluído demasiadamente o meio ambiente. Portanto, a construção do projeto
visa desenvolver, em menores proporções, um possível meio de otimizar a
captação de energia solar, que seria de grande utilidade para a questão
energética planetária, tendo em vista também o crescimento desenfreado do
número de habitantes do planeta, resultando em um aumento de consumo
energético.
O trabalho que será realizado constitui em desenvolver um dispositivo
que serve para a otimização da captação da luz solar de maneira automática.
Para isso, serão utilizados os conhecimentos em várias áreas diferentes, como
a eletrônica e a programação, que deverão ser integrados para o
desenvolvimento do projeto.
O dispositivo poderá ser tido como uma boa alternativa para o futuro,
tendo em vista a questão energética já citada, o fato de ser uma boa forma de
geração de energia limpa, e pelo fato dele ser de baixo custo.
O sensor de luminosidade será conectado ao computador, que irá
executar um software, e que por sua vez, fará os cálculos necessários para
indicar qual a direção que a placa solar precisará girar.
10
1.1. Objetivos
O objetivo principal do projeto é a construção de um dispositivo
mecânico capaz de se direcionar a fonte luminosa de maior intensidade no
ambiente em que está situado. Além disso, o desenvolvimento do dispositivo
visa o aperfeiçoamento das habilidades dos membros da equipe em relação ao
conhecimento teórico, pois será necessária a busca e integração desses
conhecimentos no decorrer do desenvolvimento do dispositivo, ou em relação
às habilidades que não estão associadas ao conhecimento teórico, como por
exemplo, o trabalho em equipe, que será muito exercitado durante a
construção do projeto.
11
1.2. Metodologia
Para a concepção e desenvolvimento do solar tracker foi aplicada uma
metodologia de desenvolvimento direta, onde as tarefas são analisadas,
executadas e testadas/verificadas. As tarefas foram divididas em diferentes
grupos.
Primeiramente, foi realizada uma análise dos requisitos do projeto,
como, por exemplo, os requisitos de hardware a serem utilizados, materiais
para a construção da base do robô, entre outros. Foram também
analisados os conteúdos envolvidos no desenvolvimento do projeto e o
tempo necessário para estudá-los e condensá-los na produção do robô.
Seguinte a essa etapa e possuindo uma noção geral do projeto, foi
produzido um cronograma de atividades a serem realizadas, tanto
individualmente como coletivamente.
Foi necessária a pesquisa e encomenda dos equipamentos de hardware
e dos materiais para construção do robô.
O projeto foi desenvolvido em cerca de 10 semanas, desde a ideia até a
implementação, com um tempo total de cerca de duzentas e cinquenta
horas gastas entre reuniões semanais, modelagem de protótipo, construção
do robô físico, desenvolvimento de código, entre outros.
12
2. FUNDAMENTAÇÃO TEÓRICA
2.1. Robôs e Robótica Robôs diferenciam-se de outros equipamentos industriais devido ao fato de
não serem controlados e operados por um humano, pois o controle é feito por
um programa contido em um computador ou dispositivo similar. Assim, se o
programa é mudado, as ações do robô também mudam, tornando possível ter
um dispositivo capaz de realizar diferentes tarefas. Isto abre uma gama de
possiblidades que pode-se fazer com o dispositivo sem necessidade de refaze-
lo.
Existem várias classificações de robôs para diferentes instituições em
países distintos. De acordo com a Associação Japonesa de Robôs Industriais
(JIRA, em sua sigla original em inglês) existem seis classes de robôs.
Classe Nome Definição Classe 1 Dispositivo de
tratamento manual Diversos níveis de liberdade, controlado por um operador
Classe 2 Robô de sequencia fixa Realiza sucessivos estágios de uma tarefa de acordo com um predeterminado método e é difícil de modificar
Classe 3 Robô de sequencia variável
Semelhante a Classe 2, porem fácil de ser modificado
Classe 4 Robô de reprodução Um operador executa a tarefa manualmente conduzindo o robô, que grava os movimentos e os repete.
Classe 5 Robô de controle numérico
O operador fornece ao robô com um programa de movimentação
Classe 6 Robô inteligente Entende o ambiente e tem a habilidade de completar uma tarefa com sucesso apesar de ocorrerem mudanças nas condições a sua volta.
Tabela 1 – Classificação de robôs segundo a JIRA
O instituto de robótica da América (RIA) considera apenas as classes de
3 a 6 como robôs. (NIKU, 2010)
13
2.1.1. Vantagens e desvantagens do uso de robôs
O uso dos robôs pode, em muitas situações, aumentar a produtividade,
segurança, eficiência, qualidade e consistência dos produtos. Em ambientes
perigosos, onde a presença humana pode ser danosa aos mesmos, possuir um
robô para executar a tarefa é extremamente vantajoso. Pois, diferente de
humanos, robôs não precisam de conforto, não sofrem de fadiga ou tédio, não
têm necessidade de seguro médico ou férias.
A precisão de repetição de um movimento é muito maior em um robô,
podendo executar o mesmo movimento várias vezes.
Porém, o uso de robôs causa problemas econômicos e sociais, como a
substituição de trabalhadores humanos por robôs, aumentando o desemprego.
Outras desvantagens são que, o robô não consegue antever situações de risco
para as quais não foi programado, podendo causar danos, mas possuem alto
custo, tanto de produção quanto de manutenção. (NIKU, 2010)
2.1.2. Componentes de Robôs
Manipulador é o corpo principal do robô, constituído por ligações e
junções.
Atuadores funcionam como os “músculos” do manipulado, exemplos
mais usuais são: servomotores, motores de passo, cilindros pneumáticos e
cilindros hidráulicos.
Os sensores são usados para coletar informações sobre o estado
interno do robô ou do ambiente à sua volta, permitindo que o robô se
comunique com o ambiente à sua volta. Exemplos comuns são: sensores de
luz, sonares, sensores de toque, entre outros.
O controlador funciona de forma semelhante ao cerebelo, controlando os
movimentos dos atuadores e coordenando o movimento com a resposta do
sensoriamento. Geralmente junto ao controlador está o processador, que
funciona como o cérebro do robô, ele calcula o movimento das junções,
determinando quanto e quão rápido cada uma irá se mover, gerenciando e
supervisionando as ações coordenadas do controlador e sensores.
14
Por fim, está o “End Effort”, ele é conectado à última junção do robô e
funciona de forma semelhante a uma mão. É quem realiza as tarefas e
conecta-se a outras máquinas. Geralmente o “End Effort” não é produzido junto
com o robô, ficando a cargo do dono providenciá-lo. O robô possui, assim,
apenas a conexão para o “End Effort”. (NIKU, 2010)
2.1.3. Orientação e movimentação de um Robô A movimentação de um robô geralmente segue uma configuração de
coordenadas pré-definidas. Junções do tipo prismática são denotadas pela
letra P e junções de revolução são denotadas pela letra R. A configuração do
robô é especificada por uma sucessão de R’s ou P’s. As mais comuns
configurações estão listadas na tabela a seguir.
Nome Sigla Descrição Cartesiana/Retangular 3P Possui três junções lineares que posicionam o
“End Effector”(sistema XYZ) Cilíndrica R2P Possui duas junções lineares e uma junção de
revolução(sistema ΡϴZ) Esférica 2RP Possui uma junção linear e duas junções de
revolução para posicionar o “End Effector” (Sistema ΡϴΦ)
Articulada/Antro mórfica
3R Possui três junções de revolução, assemelhando-se ao braço humano
Tabela 2 – Classificação de robôs por coordenadas (NIKU, 2010)
2.1.4. Características de Robôs
Payload – é o peso que o robô pode carregar sem sair de outras
especificações, como velocidade, precisão, entre outras.
Alcance – distância máxima que um robô pode alcançar dentro da
execução de suas tarefas
Precisão – é definida na forma de quão preciso um ponto especificado
pode ser atingido.
Repetitividade – Quão precisamente um robô pode atingir uma mesma
posição se o movimento é executado repetidas vezes. (NIKU, 2010)
15
2.2. Arduino
O Arduino é uma placa que contém um microcontrolador de código
aberto para o desenvolvimento fácil da comunicação usuário-hardware. Ao
utilizar o Arduino para a construção de projetos, tem-se em vista a criação de
ferramentas que são acessíveis, de baixo custo e fácil usabilidade até mesmo
para iniciantes.
Ele possui diversos pinos digitais de entrada/saída e alguns pinos
analógicos de entrada, que permite a interação do Arduino com outros
sensores. Com as informações recebidas desses sensores, ele pode interagir
também com o ambiente, fazendo o controle de luzes e motores, por exemplo.
O software Arduino, que foi escrito em Java, pode ser utilizado para a
própria programação do Arduino com a utilização da linguagem de
programação que também se denomina Arduino. (ARDUINO, 2012)
Uma grande vantagem desse dispositivo é que ele pode ser utilizado em
diversos sistemas operacionais (como Windows, GNU/Linux e MacOs).
Existem vários modelos de Arduino e o que será utilizado no nosso projeto será
o Arduino Uno. (ARDUINO, 2012) O Arduino Uno contém o microcontrolador ATmega328. Ele possui 14
pinos digitais de entrada/saída (seis deles podem ser utilizados como saída
analógica PWM), seis entradas analógicas, um cristal oscilador de 16 MHz,
uma entrada para alimentação, um botão de reset e uma porta Universal Serial
Bus (USB). (ARDUINO, 2012)
Figura 1: Arduino Uno
Fonte: http://arduino.cc/en/Main/arduinoBoardUno
16
2.3. LDR O LDR é um dispositivo eletrônico semicondutor que possui dois
terminais. Sua resistência varia de maneira linear conforme a intensidade de
luz incidente nele, obedecendo à equação R = C.L.a, em que L é a
luminosidade em Lux, C e a são constantes que dependem do processo de
fabricação e material utilizado. (UFRJ, 2012)
Figura 2: O LDR
Fonte: http://www.doctronics.co.uk/images/sens01.gif
Um dos materiais que compõem o LDR é o sulfeto de cádmio(CdS) ou o
sulfeto de chumbo (PbS). O processo de construção de um LDR consiste na
conexão do material fotossensível com os terminais, sendo que uma fina
camada é simplesmente exposta à incidência luminosa externa. (UFRJ, 2012)
ELETRODOS METÁLICOS EM CADA LADO
Figura 3: Constituição do LDR Fonte: http://www.gta.ufrj.br/grad/01_1/contador555/ldr_constituicao.gif
17
Quando o LDR é iluminado sua resistência é diminuída. Conforme a
intensidade de luz incidente nele aumenta, um número maior de elétrons na
estrutura tem também seu nível de energia aumentado, devido à aquisição da
energia entregue pelos fótons. O resultado é o aumento de elétrons livres e
elétrons fracamente presos ao núcleo. (ADÃO, 2011)
2.4. Servomotor
O servomotor é uma máquina de movimento controlado. Ao contrário de
outros motores que se movem livremente em giros, um motor deste tipo possui
liberdade de aproximadamente 180º, mas sua precisão é muito melhor que a
de um motor comum. Em geral, um servomotor possui conexões de
fornecimento de energia, saída para o terra(GND) e outra de envio de pulsos
para o movimento ser realizado.
Figura 4: Servomotor Hextronik HXT900
Fonte: http://www.msseletronica.com/loja/imagens/HXT900_2.bmp
O servo Hextronik HXT900 (Figura 4), encaixa-se no objetivo desse
projeto por ser versátil, de fácil controle e baixo consumo. Quando alimentado
com 4,8V, esse modelo possui torque de 1,6 Kg-cm e velocidade de 0,12
sec/60º. Outra vantagem é o seu peso, pesando apenas nove gramas.
Considerações sobre os sinais de pulso devem ser levadas em conta, para
18
este modelo tem-se um ciclo de pulso de 20ms e um comprimento de pulso de
450µs a 2450µs.(SERVO, 2012)
Para seu funcionamento é necessário um sensor para a identificação da
posição atual em que o motor está parado, isso é medido conforme a
resistência de um potenciômetro embutido no eixo. É também necessário um
circuito de controle e obviamente um motor.
O circuito de controle recebe a posição e o sinal de controle (que define
o movimento) e realiza a mudança de ângulo no motor. Todo o movimento é
decidido em relação ao tempo do pulso enviado ao controle.
2.4.1. Arduino e Servomotor
O Arduino possui uma classe já em sua biblioteca que é utilizada com
Servomotores, ela possui comandos de attach() e detach(), para inclusão e
exclusão de um Servomotor do circuito do arduino. No comando attach() já
podem ser incluídos como parâmetro o tempo máximo e mínimo de pulso a ser
recebido. (ARDUINO, 2012)
A classe possui também comandos como write(), writeMicroseconds(),
read() e readMicroseconds(). Os comandos write() e read() enviam e recebem
o ângulo do motor, os comandos writeMicrosends() e readMicroseconds()
recebem e enviam o tempo do pulso utilizado em microssegundos. (ARDUINO,
2012)
2.5. Divisor de Tensão Para o auxílio da resolução de um circuito elétrico, a técnica denominada
divisor de tensão pode ser aplicada. Em circuitos em série, a tensão que passa
através dos componentes resistivos será dividida entre eles conforme a
magnitude de suas resistências elétricas. Como a tensão em cada resistor
pode ser calculada pela formula V = R.I, onde R é a resistência e I é o valor da
corrente elétrica que passa sobre o componente (que terá o mesmo valor para
todos os resistores, já que eles estão em série), seria necessário apenas o
cálculo da corrente elétrica para descobrir todas as tensões sobre todos os
resistores. Entretanto, com a aplicação do método divisor de tensão, o cálculo
19
da corrente elétrica não é necessário para a obtenção das tensões sobre cada
resistor. A regra do divisor de tensão pode ser derivada analisando a Figura 5.
Figura 5: Circuito divisor de tensão
Fonte: Introductory Circuit Analysis (10th Edition), Robert L. Boylestad, p. 139
𝑅𝑡 = 𝑅1 + 𝑅2
e
𝐼 =𝐸𝑅𝑡
Aplicando a lei de Ohm:
𝑉1 = 𝐼 ∗ 1 = 𝐸𝑅𝑡 ∗ 𝑅1 =
𝑅1𝑅𝑡 ∗ 𝐸
Com
𝑉2 = 𝐼 ∗ 𝑅2 = 𝐸𝑅𝑡 ∗ 𝑅2 =
𝑅2𝑅𝑡 ∗ 𝐸
Note que o padrão para V1 e V2 é:
𝑉𝑥 = 𝑅𝑥 ∗ 𝐸𝑅𝑡
(Regra do divisor de tensão)
Onde Vx é a tensão sobre Rx, E é a tensão gerada pela fonte e RT é a
resistência equivalente do circuito.
20
Em palavras, a regra do divisor de tensão diz:
A tensão sobre um resistor em um circuito em série é igual ao valor da
resistência elétrica do resistor vezes a tensão total imposta ao circuito em série
dividido pelo valor da resistência equivalente do circuito em série.
(BOYLESTAD, 2002)
21
3. DESENVOLVIMENTO DO PROJETO
Inicialmente foi proposta a construção de um solar tracker, que levaria
em conta a movimentação do sol para expor uma placa solar a maior
intensidade luminosa possível, porem, durante o processo de criação foi notado
o fato que em outros experimentos pode ser necessário ou interessante possuir
uma forma automatizada de certa carga fique direcionada a uma fonte
luminosa seja ela o sol ou uma fonte artificial de luz. Foi então introduzida a
ideia de construir um robô direcionador de carga à uma fonte luminosa,
generalizando a ideia do solar tracker para uma fonte qualquer.
(INSTRUCTABLES, 2012)
Ainda seguindo a ideia de um solar tracker e sabendo que o novo
sistema o abrangia, foi utilizada como End Effort uma placa solar para gerar um
robô autossustentável.
Figura 6: Diagrama de blocos
Fonte: Autoria Própria.
Motor Φ
Motor ϴ
Sensor LDR(4)
Arduino
Suporte para End
Effort
Fonte de Energia
22
3.1. Sistema proposto
O sistema proposto visa, através de sensores e atuadores, manter sua
área de carga (onde, para propósitos deste, estará o componente receptor da
luz) direcionada à maior incidência luminosa possível. Para isso é preciso
medir a incidência luminosa utilizando sensores conectados ao “Arduino”, que
por sua vez, irá analisar os dados recebidos e irá controlar o movimento do
aparato através dos atuadores.
Pode-se separar a análise do conjunto nas seguintes partes: Atuadores,
Sensores, Controladores, Processador, Software e “End Effector”. Nas seções seguintes ocorrerá a descrição das partes do projeto,
divididas em hardware, software e esqueleto.
3.2. Hardware
O hardware abrange os circuitos de sensoriamento, atuação, a placa
solar para captação de energia luminosa, o sistema de fornecimento de
energia, e a central de processamento, o Arduino.
Os componentes utilizados nesse projeto foram:
- 1 Arduino UNO
- 4 Sensores LDR de 5mm
- 4 resistores de 10 kΩ
- 1 Placa solar de 2000mAh com dimensões: 10.6 cm x 4.4 cm x 1.5 cm
- 2 Servos motores HTX900 9g
- Fios de conexão.
A descrição do hardware do artefato foi dividida nas áreas apresentadas
na seção 2.1.2.
23
3.2.1. Processador/Controlador
A central de processamento de dados do robô esta localizado no
Arduino. No Arduino estão localizadas a maior parte das atividades do sistema.
O Arduino fornece energia para os outros componentes do sistema,
assim como é o neutro para os mesmos.
Para receber os dados de sensoriamento, o Arduino utiliza quatro portas
analógicas, uma para cada circuito sensor LDR. Os dados são recebidos na
forma de um numero de dez bits, essa informação é passada para o software,
que será tratado na seção seguinte.
O Arduino controla também os servomotores, o software envia a
informação para o hardware, que controla os servomotores usando suas portas
digitais do tipo PWM.
3.2.2. Atuadores
Os atuadores aparecem na forma de dois servomotores, que funcionam
como os músculos do robô, movendo o esqueleto de acordo com os sinais
recebidos. O circuito dos atuadores não possuem elementos especiais, sendo
os atuadores diretamente conectados ao Arduino, em suas portas digitais
PWM.
O robô segue um sistema de coordenadas esféricas, possuindo duas
junções de revolução. Porem não existe variação no raio, que permanece
inalterado, dando sendo assim uma configuração do tipo 2R (duas junções de
revolução). O robô possui então liberdade de movimento em duas dimensões.
Cada atuador se move para um determinado ângulo variando de 0o a
180º. Essa liberdade de 180º não permite que o suporte do End Effector fique
completamente direcionado para a base do robô, como mostra a Figura 7.
24
Figura 7: Possíveis posições do servomotor Fonte: Autoria Própria.
3.2.3. End Effector
O End Effector fica a critério do utilizador do robô resultado desse
projeto. Como suporte para o End Effector foi utilizada uma caixa plástica com
comprimento de 140mm , largura de 63mm e profundidade de 32mm (143mm
X 63mm X 32mm). Esse suporte estará sempre direcionado à maior
intensidade luminosa.
Como exemplo de uso, usa-se como End Effector uma placa solar de
dimensões concordantes com o suporte, essa placa solar será, pelo robô,
sempre direcionada a maior intensidade luminosa, fato que permitirá uma
captação máxima de energia solar.
3.2.4. Sensores
Como o objetivo do robô resultado é manter seu suporte de carga
direcionada a maior intensidade luminosa, foram utilizados sensores LDR
externos, que, como explicado detalhadamente em seções anteriores, tem sua
25
resistência mínima com a intensidade luminosa máxima e sua resistência
máxima com a intensidade luminosa mínima.
O LDR é um sensor analógico, já que medimos a tensão sobre ele em
função da luminosidade. A tensão sobre o LDR é medida a cada intervalo de
tempo, gerando assim dados digitais a partir da leitura analógica.
Para o sistema de sensoriamento são utilizados quatro sensores LDR,
com suas localizações descritas como na Figura 8.
Figura 8: Posições dos LDR’s Fonte: Autoria Própria.
A disposição dos sensores desta maneira permite uma rápida e eficiente
análise da necessidade do movimento e para onde ele deve ser feito. O modo
como é feita essa análise será descrita em seções posteriores.
Utilizando uma porta analógica do Arduino é possível medir a tensão em
um ponto em referencia ao ponto neutro (GND). Porem um circuito de
sensoriamento contendo apenas um sensor LDR seria inviável, já que existem
muitas variáveis desconhecidas (A corrente e resistência do LDR), portanto
utiliza-se em serie um resistor de valor conhecido e monta-se o circuito da
Figura 9.
26
Figura 9: Circuito divisor de tensão para o sistema de sensoriamento Fonte: Autoria Própria.
Como pode ser visto na Figura 9, a tensão medida pela porta analógica
do Arduino é a tensão sobre o resistor, e não sobre o sensor LDR. Tendo a
tensão sobre o resistor e conhecendo sua resistência é possível determinar a
corrente através do circuito, que é a mesma corrente no Arduino. Como se
sabe a corrente no sensor LDR e a sua tensão é dada pela diferença entre a
tensão fornecida ao circuito e a tensão lida na porta analógica, a resistência do
sensor LDR é dada pela lei de Ohm.
3.3. Software
O software foi desenvolvido utilizando a linguagem de programação
“Arduino”, linguagem essa, utilizada na placa de microcontrolador de mesmo
nome. O ambiente de desenvolvimento utilizado foi o “Arduino software”,
compilador e transmissor do código para o microcontrolador.
27
Figura 10: Ambiente de desenvolvimento Arduino Fonte: Autoria Própria.
O software gerencia o sensoriamento e atuação do robô. Um diagrama
de classes completo do software assim como o código desenvolvido esta na
seção de apêndices.
O código é divido em três partes, controle, sensoriamento e atuação. O
controle integra as outras partes, primeiramente busca-se o sensoriamento e
dependendo da sua resposta, é efetuada a atuação.
O sensoriamento requisita os valores nas portas analógicas usadas,
converte o número de dez bits recebido em um valor real de tensão, pela
equação abaixo:
28
𝑉!"#$ = 𝑉!"#$×5
1024
Tendo a tensão sobre o resistor, é efetuado o cálculo para determinar a
resistência do LDR pela equação a seguir:
𝑅!"# = 𝑉!"#$×𝑅!𝑉!! − 𝑉!"#$
Onde R1 é uma resistência fixa.
Como descrito na seção do sensoriamento, foi definido um sistema de
sensoriamento baseado em quatro sensores LDR. O procedimento acima
descrito é realizado para cada um dos sensores LDR. É possível, então,
analisar a incidência luminosa em cada ponto.
Caso o modulo das diferenças entre resistências seja menor do que um
fator de erro, não é necessário movimentos
Porem, quando o modulo da diferença entre as resistências for maior
que o fator de erro, é necessário um movimento. O movimento é direcionado
para a direção da menor resistência, em consequência maior intensidade
luminosa.
São calculadas duas diferenças entre as resistências, como mostra a
inequação seguinte:
𝑅! − 𝑅! > 𝑒𝑟𝑟
𝑅! − 𝑅! > 𝑒𝑟𝑟
Onde RT é a resistência do LDR superior, RB é a resistência do LDR
inferior, RL é a resistência do LDR esquerdo e RR é a resistência do LDR
direito.
Caso uma ou ambas inequações for verdadeira, é verificado qual o menor
valor entre as resistências de cada equação, definindo-se assim a direção do
movimento.
29
A atuação é realizada utilizando-se a biblioteca Servo que está inclusa no
pacote de desenvolvimento Arduino. A biblioteca fornece métodos que
permitem ligar virtualmente o Arduino ao servomotor e determinar o ângulo do
servomotor em graus. A atuação então recebe por parâmetro o motor que deve
rotacionar. A rotação é feita somando-se ou subtraindo um fator em graus a
posição atual. Deve-se levar em conta que o valor resultado dessa adição ou
subtração não deve ultrapassar os limites de 0o e 180o, já que estes valores
excedem os limites físicos do servomotor.
3.4. Esqueleto
O projeto foi modelado em 3 dimensões no programa Google Sketchup
com as medidas exatas de cada parte. Com o modelo pronto pudemos pegar
cada peça separadamente (base e haste) colocar em um PDF e anotar as
medidas no arquivo, este foi enviado para a empresa DynamicLaser que
realizou os cortes em peças de acrílico e MDF.
Figura 11: Modelo 3D em visão geral Fonte: Autoria Própria.
A haste no início possuía tamanhos iguais em cada lado, mas
verificamos que esta não era a melhor forma, pois tínhamos 3cm de motor a
ser colocado nela. Decidimos então colocar o Servo em um dos lados e
30
compensar em altura no outro igualando assim o eixo central de rotação do
suporte.
Figura 12: Haste em destaque no modelo 3D(a) e em acrílico(b) Fonte: Autoria Própria.
A base foi feita em formato circular, pois ela é o centro de rotação. Nela
são colocados a haste e o Arduino em cima, e abaixo é acoplado o servo. Pela
figura podemos ver também um furo de 3mm de raio que foi feito para a
passagem dos fios dos LDRs e dos Servomotores.
31
Figura 13: Base em destaque no modelo 3D(a) e em acrílico(b) Fonte: Autoria Própria.
Para melhor execução do giro da base utilizaremos 3 esferas de
desodorante do tipo roll-on abaixo da base circular do projeto, isso faz o apoio
e a diminuição da força que o motor necessitará para iniciar e manter o giro.
32
Figura 14: Esferas em destaque no modelo 3D Fonte: Autoria Própria.
O Arduino será posicionado à frente na base, próximo ao orifício
representado na Figura 13. Nesta posição ele acompanha a rotação e as peças
podem girar livremente sem nenhum fio segurando-as. Os 4 LDRs serão
colocados no suporte, um em cada centro de cada lado dele, como é mostrado
na figura.
Figura 15: Arduino e LDRs em destaque no modelo 3D Fonte: Autoria Própria.
33
Dois Servomotores são utilizados no projeto, um para a rotação de toda
a base e outro para a rotação do suporte com os LDRs. Ambos rotacionam
conforme os pulsos enviados via Arduino. Com estes dois motores
conseguimos todo o movimento necessário para ajuste do suporte em direção
a uma fonte de luz.
Figura 16: Servomotores em destaque no modelo 3D Fonte: Autoria Própria.
As vantagens de se fazer um modelo 3D são que, além de podermos
visualizar melhor os componentes para obter novas ideias e discutir o projeto,
podemos enviar para a empresa de corte de peças os modelos com as
medidas, assim realizando fisicamente o projeto pensado. A escolha de
posição dos motores foi pensada como um espelho de mesa com uma
liberdade a mais, a rotação da base.
34
Figura 17: Espelho de mesa
Fonte: http://www.mancave.co.nz
3.4.1. Materiais
No projeto foram utilizados dois materiais: MDF e acrílico; foram
escolhidos esses devido à resistência e a possibilidade de cortar-se a laser,
também foi cogitada a utilização de plástico e foam.
Com relação ao primeiro material, foi discutido e observado que, como o
nosso projeto deve ficar exposto ao sol ou a alguma fonte de luz infravermelha
é inviável sua utilização, pois alguns tipos de plástico derretem com a
exposição contínua (excessiva) a essas fontes.
Figura 18: Chapas de plástico
Fonte: http://www.actos.com.br/imagens/dados/p2334.jpg
35
Já o segundo, a princípio, foi considerado pela equipe como primeira
opção e, após ter sido analisado mais cuidadosamente, verificou-se que,
embora o material fosse muito leve e fácil de cortar, ele não seria resistente o
suficiente para aguentar a estrutura na posição vertical.
Figura 19: Chapas de foam
Fonte: http://www.hspnet.com.br/site/products_pictures/ID_8520_dayfoam.jpg
Logo quando fomos procurar a empresa que fizesse corte a laser, nos
foram oferecidas duas possibilidades de materiais que são resistentes e que
possuem rigidez, além disso, ainda podiam ser cortados a laser, eles são: o
MDF e o acrílico.
3.5. Custos
Para o projeto foram comprados 4 (quatro) LDR’s para a análise de
ângulo de incidência dos raios, 2 (dois) Servomotores para a movimentação de
todo o sistema em todas as posições necessárias e um Arduino para controle
de todos os componentes. Levando em consideração os seguintes preços:
LDR R$2,50 cada (~U$D1.32 each), Servo motor R$14,00 (~U$D7.42) e
Arduino ~R$39,59 (U$D21.00). Para visualização do projeto segue abaixo uma
tabela.
36
Componente Quantidade Preço (un.) U$D Total Placa Solar 1 14,60 14,60
LDR 6 1,32 5,28
Servomotor 2 7,42 14,84
Arduino 1 21,00 21,00
Total (U$D) 58,36
Tabela 3 – Componentes, quantidade e preço* *Cotação do dólar da época utilizada 1 dólar = 1,885298 reais
As peças foram enviadas para corte na empresa DynamicLaser, os
custos já incluem o material e corte segundo tabela abaixo.
Componente Preço em MDF (R$ / U$D) Preço em Acrílico (R$ / U$D) Haste 10,00 / ~4.85 15,00 / ~7.28 Base 9,00 / ~4.37 - Base com furo - 15,00 / ~7.28 Total (U$D) 23.78
Tabela 4 – Peças do esqueleto* *Cotação do dólar da época utilizada 1 dólar = 2,06050041 reais
A placa solar colocada na primeira tabela de cotações foi colocada como
exemplo de utilização do nosso projeto, uma melhoria de captação dos raios
solares para gerar energia. Considerando os gastos dos componentes iniciais
(Placa solar, LDRs, Servomotores e Arduino [U$D58.36]) e dos cortes (Haste,
Base e Base com furo [U$D23.78]) o investimento total para a realização do
mesmo foi de U$D82.14, considerando as diferentes taxas cambiais em cada
tabela.
37
3.6 Problemas, erros e possíveis soluções
Nessa seção serão listados os problemas e erros que o dispositivo
produzido como resultado dessa monografia tem, e algumas possíveis
soluções para futuras implementações.
3.6.1 Limitação de movimentação
O dispositivo produzido possui movimentação limitada devido ao fato de
ter sido construído usando servomotores com um alcance de 0° a 180°, isso
restringe a movimentação seriamente, impossibilitando que a placa seja
direcionada para uma direção.
Para resolver tal problema seria necessária a implementação de outro
tipo de motor, por exemplo um motor de passo. Além disso, seria necessário
alterar a classe referente ao atuador para suportar esse outro tipo de motor.
Outro problema referente a movimentação deve-se a localização da
fiação. Devido ao grande número de fios provindos da alimentação,
aterramento e sinais do circuito e do pequeno tamanho do artefato, interfere na
movimentação das junções que não possuem força necessária para rotacionar
o artefato. Para solucionar esse problema, seria necessário produzir uma haste
de maior altura para, assim, ter uma folga para o posicionamento do fio.
3.6.2 Detecção da não necessidade de movimento em condições de baixíssima luminosidade
Foi notado no decorrer do projeto que, em condições de baixíssima
luminosidade, as resistências dos LDRs assumiam valores muito altos, por
volta de dezenas de mega ohms, além de que a taxa de erro adotada durante o
38
projeto deixava de ser suficiente para essas condições, causando o efeito de o
dispositivo não permanecer em repouso nessas condições.
A resolução de tal problema pode ser realizada via software, uma das
possíveis soluções seria criar um limite inferior de luminosidade para o
funcionamento (limite superior de resistência) podendo esse limite variar de
acordo com a aplicação desejada.
Outra possível solução via software seria a implementação de uma taxa
de erro maior, porém essa taxa maior poderia atrapalhar a análise de
movimentos para valores maiores de resistência. Para evitar isso poderia ser
adotada essa nova margem de erro apenas para valores de luminosidade
abaixo de um limite desejado.
No dispositivo desse projeto a tensão utilizada para alimentar todos os
circuitos foi a tensão do próprio arduino, que é tabelada como sendo cinco
volts, mas a tensão fornecida pelo arduino não é sempre igual a cinco volts,
esse valor geralmente acaba sendo menor. Utilizar uma fonte externa a do
arduino para alimentar os outros circuito deve trazer uma maior precisão ao
sensoriamento.
5. CONCLUSÕES
Ao inicio desse projeto, pretendia-se construir um solar tracker,
dispositivo que tem função única direcionar ao sol sua área de carga. Porém,
durante as analises teóricas e produção deste, percebeu-se a possibilidade de
expandir o projeto de uma forma simples. Além de direcionar ao sol, direciona-
se a qualquer fonte luminosa sem grandes alterações no projeto.
A decisão da mudança ocorreu após o pedido de importação da placa
solar, que seria utilizada anteriormente. Usando os estudos na área de robótica
foi possível definir um uso para a placa solar, sendo a mesma utilizada como
“End Effort”. Nesse caso o dispositivo funciona como no anteriormente
proposto solar tracker. Sendo esse, por sua vez, autossustentável, ou seja,
consome a energia que gera.
39
Conforme citado anteriormente, o objetivo do projeto foi alterado durante
a execução do mesmo. Não foram realizadas implementações para melhor
posicionar o dispositivo em relação ao sol, como previsto anteriormente,
utilizando as movimentações do astro em relação a Terra.
A grande vantagem da construção do robô é uma fácil mudança de
função do mesmo, sendo este versátil. Podendo tanto seguir qualquer fonte
luminosa, como também utilizar diferentes tipos de “End Effort” , um deles já
demonstrado como sendo a placa solar, e outras utilizações descritas na seção
de aplicações e trabalhos futuros.
Na construção do protótipo foram encontradas dificuldades com a
escolha do material usado no esqueleto, dúvidas surgiram devido à
possibilidade do dispositivo ficar durante um longo período de tempo exposto à
luz solar, podendo assim causar aquecimento do esqueleto e dos
componentes. Ainda em relação ao aquecimento do dispositivo, o uso da placa
solar pode causar desgastes, pela mesma aquecer muito quando exposta ao
sol. Outra consideração foi em relação ao peso do esqueleto e à capacidade
dos motores se manterem eficientes. Por fim decidiu-se fazer dois esqueletos,
um primeiro, mais leve, com material do tipo MDF, um segundo, mais pesado,
porem mais resistente, feito em acrílico.
No âmbito pessoal, pode-se perceber que o tempo analisando um
problema e estruturando sua solução é indispensável no função de um
engenheiro. Uma análise bem feita pode economizar tempo de
desenvolvimento e dinheiro. É plausível, então, afirmar que a produção deste
trabalho influencia positivamente na formação de um Engenheiro de
Computação qualificado.
Ainda no âmbito pessoal, percebeu-se a falta de experiência da equipe e
necessidade de melhora no controle e projeção de tarefas. Assim como na
análise de mercado para investimentos na compra de equipamentos e
materiais, dificuldades essas que atrasaram o cronograma previsto.
40
6. REFERÊNCIAS
ADÃO, Laudelino Jr.; ANTUNES, Alexandre R.; KAMADA, Naomi C.;
NAKANISHI, Sergio A. Massami; Sensor de Intensidade Luminosa Baseado em Arduino. 2011. Universidade Tecnológica Federal do Paraná
ARDUINO. Arduino. Disponível em: http://arduino.cc/ , acessado em Abril,
2012.
BOYLESTAD, Robert L.; Introductory Circuit Analysis 10th Edition, 2002.
INSTRUCTABLES. Arduino 2-Axis Solar tracker. Disponível em:
http://www.instructables.com/id/Arduino-2-axis-servo-solar-tracker/ , acessado
em Abril, 2012.
NIKU, Saeed B. Introduction to Robotics: Analysis, Systems, Applications.
Prentice Hall, 2010.
41
SERVO. Hextronik HXT900 Microservo. Disponível em:
http://www.servodatabase.com/servo/hextronik/hxt900 , acessado em Maio,
2012.
UFRJ, LDR. Disponível em:
http://www.gta.ufrj.br/grad/01_1/contador555/ldr.htm , acessado em Maio, 2012.
APÊNDICE A – Diagrama de classes do software
42
APÊNDICE B – Software desenvolvido #include <Servo.h> //------------------------------------------------------------------------------------ //------------------------------Classe LDR-------------------------------------------- //Descricao: Cada objeto dessa classe representa um LDR. A classe tem funcao de // salvar a pino de leitura do LDR e realizar a leitura //Autor: Laudelino Adao Junior, Vinicius Silva Mazzola, Juan Pietro e Sergio Augusto. //------------------------------------------------------------------------------------ class LDR { private: int sensorPin; double rvalue; double resistencia; double Vldr; public: void init(int sp) { sensorPin = sp; } //Faz uma media de 3 leituras em um intervalo de 30ms e retorna a resistencia double readLDR() { Vldr = 0; for(int i =0; i<3; i++)
43
{ delay(10); rvalue = analogRead(sensorPin); Vldr += rvalue*5/1024; } Vldr = Vldr/3; resistencia = (Vldr*10000)/(5-Vldr); return resistencia; } }; //------------------------------------------------------------------------------------ //------------------------------Classe Sensing---------------------------------------- //Descricao: é composta pelos LDR, ela tem funcao de pedir a leitura de cada LDR e // analisar a necessidade de movimento. //Autor: Laudelino Adao Junior, Vinicius Silva Mazzola, Juan Pietro e Sergio Augusto. //------------------------------------------------------------------------------------ class Sensing { private: LDR top, bottom, left, right; int pos; double err; String girar; public: void init() { err = 0; top.init(2);//Top bottom.init(1);//Botton left.init(3);//Left right.init(0);//Right pos = -1;//Botton = 1; Top = 2; Left = 3; Right = 4; } int compare() { double media = 0, rTop = top.readLDR(), rBottom = bottom.readLDR(), rLeft = left.readLDR(), rRight = right.readLDR(); pos = 0; girar = ""; err = 0.20; //O resistor tem uma margem de erro de 5%, ja o LDR eh responsavel pelos outros 13% //O erro é multiplicado pela media entre o sendo verificado e o oposto dele. if(rTop < rBottom && rTop < rLeft && rTop < rRight)//Verifica se o menor eh o do topo { pos = 2;
44
girar = "Top"; media = (rTop/2 + rBottom/2); // Calcula a media com o oposto err*= media; } else if(rBottom < rLeft && rBottom < rRight) { pos = 1; girar = "Bottom"; media = (rTop/2 + rBottom/2); // Calcula a media com o oposto err*= media; } else if(rLeft<rRight) { pos = 3; girar = "Left"; media = (rLeft/2 + rRight/2);// Calcula a media com o oposto err*= media; } else { pos = 4; girar = "Right"; media = (rLeft/2 + rRight/2); // Calcula a media com o oposto err*= media; } /* Serial.println(""); Serial.println(pos); Serial.print("ERRO: "); Serial.println(err); Serial.print("Girar para: "); Serial.println(girar); Serial.println("TODOS:"); Serial.print("Bottom = "); Serial.println(rBottom); Serial.print("Top = "); Serial.println(rTop); Serial.print("Right = "); Serial.println(rRight); Serial.print("Left = "); Serial.println(rLeft); Serial.println("");*/ //verifica se o modulo da diferenca com o oposto eh maior que o erro, se for, retorna para onde deve girar, senao retorna 0 switch(pos) { case 1: { if(abs(rTop-rBottom) > err) return pos; else return 0; }
45
case 2: { if(abs(rTop-rBottom) > err) return pos; else return 0; } case 3: { if(abs(rLeft-rRight) > err) return pos; else return 0; } case 4: { if(abs(rLeft-rRight) > err) return pos; else return 0; } default: return 0; } } }; //------------------------------------------------------------------------------------ //------------------------------Classe Actuator--------------------------------------- //Descricao: Conecta e desconecta os servos motores em um pino, define a posicao // inicial e gira conforme a necessidade //Autor: Laudelino Adao Junior, Vinicius Silva Mazzola, Juan Pietro e Sergio Augusto. //------------------------------------------------------------------------------------ class Actuator { private: Servo xServo, yServo; int xTheta, yTheta, xRot, yRot, xPin, yPin; public: void init() { yPin = 9; xPin = 10; xTheta = 90; yTheta = 90; xRot = 5;//Valor de rotacao no eixo X yRot = 5;//Valor de rotacao no eixo X //Inicializa ambos os servos em 90 graus yServo.attach(yPin); yServo.write(yTheta); delay(120); yServo.detach(); xServo.attach(xPin);
46
xServo.write(xTheta); delay(120); xServo.detach(); } void rotateTop() { yTheta = yServo.read(); if((yTheta + yRot) > 180) { //nao pode mais girar para baixo Serial.println("No rotation possible"); delay(5); } else { yTheta += yRot;//Gira para direcao indicada yServo.attach(yPin); yServo.write(yTheta); delay(120); yServo.detach(); } } void rotateBottom() { yTheta = yServo.read(); if((yTheta - yRot) < 0) { //nao pode mais girar para baixo Serial.println("No rotation possible"); delay(5); } else { yTheta -= yRot;//Gira para direcao indicada yServo.attach(yPin); yServo.write(yTheta); delay(120); yServo.detach(); } } void rotateLeft() { xTheta = xServo.read(); if((xTheta + xRot) > 180) { //nao pode mais girar para baixo Serial.println("No rotation possible"); delay(5); } else { xTheta += xRot;//Gira para direcao indicada xServo.attach(xPin); xServo.write(xTheta);
47
delay(120); xServo.detach(); } } void rotateRight() { xTheta = xServo.read(); if((xTheta - xRot) < 0) { //nao pode mais girar para baixo Serial.println("No rotation possible"); delay(5); } else { xTheta -= xRot;//Gira para direcao indicada xServo.attach(xPin); xServo.write(xTheta-xRot); delay(120); xServo.detach(); } } }; //------------------------------------------------------------------------------------ //------------------------------Classe Control---------------------------------------- //Descricao: Une as classes sensing e control, pede a posicao para qual girar para a // sensing e manda girar o necessario na control //Autor: Laudelino Adao Junior, Vinicius Silva Mazzola, Juan Pietro e Sergio Augusto. //------------------------------------------------------------------------------------ class Control { private: Sensing s; Actuator a; int pos; public: void init() { s.init(); a.init(); pos = 0; } //Busca se e para onde deve mover, e chama o metodo correspondente para ocorrer esse movimento. void move() { pos = s.compare(); switch(pos) { case 0: Serial.println("No move neded"); break; case 1: a.rotateBottom(); Serial.println("Moving down"); break; case 2: a.rotateTop(); Serial.println("Moving up"); break;
48
case 3: a.rotateLeft(); Serial.println("Moving left"); break; case 4: a.rotateRight(); Serial.println("Moving right"); break; default: return; } } }; Control c; void setup() { Serial.begin(9600); c.init(); } void loop() { c.move(); delay(100); }
49
APÊNDICE C – Diagrama de Gantt