SISTEMA DE MONITORAMENTO E REGISTRO DE DADOS PARA APOIO À
NAVEGAÇÃO DE UM VEÍCULO SOLAR
Guilherme Arnizaut
Projeto de Graduação apresentado ao Curso de
Engenharia Elétrica da Escola Politécnica,
Universidade Federal do Rio de Janeiro, como parte
dos requisitos necessários à obtenção do título de
Engenheiro Eletricista.
Orientador: Luís Guilherme Barbosa Rolim, Dr.-Ing
Rio de Janeiro
Julho de 2014
ii
SISTEMA DE MONITORAMENTO E REGISTRO DE DADOS PARA APOIO À
NAVEGAÇÃO DE UM VEÍCULO SOLAR
Guilherme Arnizaut
PROJETO DE GRADUAÇÃO SUBMETIDO AO CORPO DOCENTE DO CURSO DE
ENGENHARIA ELÉTRICA 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
ELETRICISTA.
Examinado por:
________________________________________________
Prof. Luís Guilherme Barbosa Rolim, Dr. -Ing
(Orientador)
________________________________________________
Prof. Jorge Luiz do Nascimento, Dr.Eng.
(Coorientador)
________________________________________________
Prof. Sergio Sami Hazan, Ph.D.
________________________________________________
Marcos Dantas Alves dos Santos, M.Sc.
RIO DE JANEIRO, RJ - BRASIL
JULHO DE 2014
iii
Arnizaut, Guilherme
Sistema de Monitoramento e Registro de Dados Para
Apoio à Navegação de um Veículo Solar / Guilherme Arnizaut.
– Rio de Janeiro: UFRJ / Escola Politécnica, 2014.
XIV, 101 p.: il.: 29,7 cm
Orientador: Luís Guilherme Barbosa Rolim
Projeto de Graduação – UFRJ / Escola Politécnica / Curso
de Engenharia Elétrica, 2014.
Referências Bibliográficas: p.80-81.
1. Barco Solar. 2. Captação de Dados. 3. Armazenamento
de Dados. 4. Sensores. I. Rolim, Luís Guilherme Barbosa. II.
Universidade Federal do Rio de Janeiro, Escola Politécnica,
Curso de Engenharia Elétrica. III. Título
iv
Agradecimentos
Agradeço a Deus por estar comigo nessa jornada me dando saúde e confiança e
me ajudando a superar os desafios.
A toda minha família, presentes fisicamente ou não, que sempre esteve presente
me dando toda a base moral e valores que hoje eu sigo e respeito.
Em especial ao meu pai, Jefferson Arnizaut, e minha mãe, Márcia Ribeiro, que
por todo o meu percurso forneceram todo suporte que alguém pode pedir para estar
sempre seguindo em frente, a grande paciência que tiveram para eu chegar até aqui e a
sempre confiança em minha capacidade que fez que eu mesmo acreditasse em mim.
À minha namorada, Letícia Bandeira de Castro, por toda a força que me deu de
para que eu pudesse seguir meus objetivos.
A toda família de Fabio Fernandes Figueira, por receberem a mim e meus colegas
em intermináveis noites de estudo.
Aos meus amigos Fabio Fernandes Figueira, Marcos Póvoa e Pedro Altoé, sem os
quais as noites viradas de estudos teriam sido mais chatas e menos produtivas.
A todos os amigos que fiz durante minha passagem pela faculdade, que nossa
amizade seja duradoura.
A todos do LAFAE, em especial a Marcos Dantas, pelos conselhos e ajudas tanto
nas experiências quanto nas preparações para as mesmas.
Agradeço ao Professor Luís Guilherme Barbosa Rolim pela ajuda e conselhos no
desenvolvimento deste projeto.
v
“O Conflito Não é Entre
o Bem e o Mal,
mas entre o Conhecimento
e a Ignorância”
(BUDA)
vi
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 Eletricista.
Sistema de Monitoramento e Registro de Dados Para Apoio à Navegação de um
Veículo Solar
Guilherme Arnizaut
Julho/2014
Orientador: Luís Guilherme Barbosa Rolim
Curso: Engenharia Elétrica
Este projeto visa desenvolver e descrever um sistema de monitoramento e registro de
dados que busca auxiliar a navegação do barco movido a energia solar (barco solar)
pertencente ao Laboratório de Fontes Alternativa de Energia (LAFAE). Esse sistema será
capaz de captar e armazenar dados de sensores dispostos no barco, sendo que os sensores
usados nesse trabalho foram um sensor de corrente Allegro ACS758, um sensor
piranômetro Davis de Radiação Solar e ainda um divisor de tensão resistivo que
representa um sensor de tensão. Os dados captados serão utilizados em uma posterior
análise e desenvolvimento do barco focando-se nos sistemas de geração fotovoltaica,
armazenamento de energia e propulsão.
Palavras-chave: Barco Solar, Captação de Dados, Armazenamento de Dados, Sensores.
vii
Abstract of Undergraduate Project presented to POLI/UFRJ as a partial fulfillment of the
requirements for the degree of Engineer.
Monitoring and Data Registration System for Support the Navigation of a Solar Vehicle
Guilherme Arnizaut
July/2014
Advisor: Luís Guilherme Barbosa Rolim
Course: Electrical Engineering
This project aims to develop and describe a system for monitoring and datalogging
seeking to assist the navigation of the boat powered by the sun (solar boat) that belongs
to the Laboratory of Alternative Energy Sources (LAFAE). This system will be able to
capture and store data from sensors scattered throughout the boat, the sensors used were
a current Allegro ACS758 sensor, a pyranometer Davis Solar Radiation sensor and a
resistive voltage divider, which represents a voltage sensor. The data acquired will be
used for further analysis and development of the boat by focusing on the photovoltaic
generation system, energy storage system and propulsion system.
Keywords: Solar Boat, Data Capture, Data Storage, Sensors.
viii
Sumário
Lista de Figuras ............................................................................................................... xi
Lista de Tabelas ............................................................................................................. xiv
Capítulo 1 – Introdução ................................................................................................ - 1 -
1.1 Contexto .............................................................................................................. - 1 -
1.2 Objetivo .............................................................................................................. - 6 -
1.3 Metodologia ........................................................................................................ - 6 -
1.4 Organização ........................................................................................................ - 7 -
Capítulo 2 – Composição do Sistema ........................................................................... - 9 -
2.1 Introdução ........................................................................................................... - 9 -
2.2 O Barco Solar ...................................................................................................... - 9 -
2.3 Componentes do sistema .................................................................................. - 18 -
2.3.1 Sensores ...................................................................................................... - 18 -
2.3.2 Dispositivo de Concentração e Armazenamento de Dados ....................... - 24 -
Capítulo 3 –Programação do Arduíno ........................................................................ - 30 -
3.1 Introdução ......................................................................................................... - 30 -
3.2 Arduíno UNO ................................................................................................... - 30 -
3.3 Arduíno IDE ..................................................................................................... - 33 -
3.4 Programa Base de aquisição de Dados ............................................................. - 34 -
3.4.1 Teste preliminar do Programa 1 ................................................................. - 39 -
3.5 Programa Completo de Aquisição de Dados .................................................... - 40 -
ix
3.5.1 Teste Preliminar do Programa 2 ................................................................. - 41 -
3.6 Programa de Aquisição de Dados do GPS ........................................................ - 42 -
3.6.1 Shield GPS ITEAD Studio ......................................................................... - 42 -
3.6.2 Desenvolvimento do Programa .................................................................. - 44 -
3.7 Programa para Captação de dados dos Sensores e GPS ................................... - 47 -
Capítulo 4 – Montagens, Testes, Validações e Calibrações ....................................... - 50 -
4.1 Introdução ......................................................................................................... - 50 -
4.2 Sensores Reais .................................................................................................. - 50 -
4.2.1 Sensor de Corrente ACS758ECB-200B ..................................................... - 51 -
4.2.2 Sensor Piranômetro Vantage Pro ............................................................... - 53 -
4.3 Placa de Interconexão ....................................................................................... - 56 -
4.3.1 Teste preliminar da Placa ........................................................................... - 60 -
4.4 Ideia de Aplicação das Placas ........................................................................... - 61 -
4.5 Curvas de Calibração ........................................................................................ - 62 -
4.5.1 Curva de Calibração do Sensor de Corrente .............................................. - 62 -
4.5.2 Curva de Calibração do Piranômetro ......................................................... - 65 -
Capitulo 5 –Resultados. .............................................................................................. - 70 -
5.1 Principais Resultados ........................................................................................ - 70 -
5.2 Ampliações ....................................................................................................... - 73 -
Capítulo 6 – Conclusão .............................................................................................. - 74 -
6.1 Objetivos Alcançados ....................................................................................... - 74 -
6.2 Temas para Futuros Projetos ............................................................................. - 75 -
x
6.2.1 Dispositivo Móvel para Interface com o Usuário ...................................... - 75 -
Referências Bibliográficas .......................................................................................... - 80 -
Anexo I ....................................................................................................................... - 82 -
Anexo II ...................................................................................................................... - 85 -
Anexo III .................................................................................................................... - 89 -
Anexo IV .................................................................................................................... - 94 -
xi
Lista de Figuras
Figura 1- Ônibus Híbrido a Hidrogênio ....................................................................... - 2 -
Figura 2- Ford Modelo C-Max Energi Solar ................................................................ - 3 -
Figura 3-Formato do Casco do Barco Mangue .......................................................... - 10 -
Figura 4-Vista lateral do Catamarã Mangue............................................................... - 10 -
Figura 5-Topologia e Circuito Equivalente de um Motor BLDC .............................. - 11 -
Figura 6-Imagem do Motor em Funcionamento e em Repouso ................................. - 12 -
Figura 7-Motor C80100-180 Turnigy......................................................................... - 12 -
Figura 8-ESC do Motor .............................................................................................. - 14 -
Figura 9-Conjunto Motor, Rabeta e Hélice ................................................................ - 14 -
Figura 10-Bateria Modelo Freedom DF300 12V ....................................................... - 15 -
Figura 11-Esquema Atual de Propulsão e controle .................................................... - 17 -
Figura 12- Sensor de Corrente Allegro....................................................................... - 18 -
Figura 13-Sensor de Tensão ....................................................................................... - 20 -
Figura 14-Diagrama de Correntes .............................................................................. - 20 -
Figura 15– Diagrama dos Sensores se Conectando ao Dispositivo Concentrador de
Dados .......................................................................................................................... - 23 -
Figura 16-Caixa Hermética da Hypersat .................................................................... - 26 -
Figura 17-Placa da família Arduíno ........................................................................... - 27 -
Figura 18- Shields Acoplados no Arduíno ................................................................. - 29 -
Figura 19-- Arduíno UNO .......................................................................................... - 32 -
Figura 20-Tela inicial do Arduíno IDE com funcionalidades destacadas .................. - 34 -
Figura 21- Fluxograma do programa Base ................................................................. - 36 -
Figura 22– Esquemático do teste do Programa 1 ....................................................... - 39 -
xii
Figura 23– Representação do Teste 1 ......................................................................... - 40 -
Figura 24– Esquemático do teste do programa .......................................................... - 41 -
Figura 25- Representação do Teste 2 ......................................................................... - 42 -
Figura 26– Diagrama de Layout do GPS Shield ........................................................ - 43 -
Figura 27– ITEAD GPS Shield e Antena ................................................................... - 44 -
Figura 28– Fluxograma GPS ...................................................................................... - 45 -
Figura 29– Fluxograma do programa completo ......................................................... - 48 -
Figura 30– Esquemático do ACS758 ......................................................................... - 52 -
Figura 31– Diagrama de Pinagem .............................................................................. - 52 -
Figura 32– ACS758 PFF ............................................................................................ - 53 -
Figura 33– Corpo interno do Piranômetro .................................................................. - 55 -
Figura 34– Corpo Externo do Piranômetro ................................................................ - 55 -
Figura 35– Esquemático do Piranômetro ................................................................... - 56 -
Figura 36– Primeira Placa Produzida ......................................................................... - 57 -
Figura 37– Problema de Sustentação Apresentado pela Placa ................................... - 58 -
Figura 38– Vista Superior da Placa de Interconexão Final ........................................ - 59 -
Figura 39– Placa Empilhada com o Problema de Sustentação Resolvido ................. - 59 -
Figura 40– Piranômetro e Fonte conectados à Placa .................................................. - 60 -
Figura 41– Todas as Conexões Feitas para o Teste .................................................... - 61 -
Figura 42– Curva de Calibração do Sensor de Corrente ............................................ - 64 -
Figura 43– Experimento para Levantamento da Curva de Calibração ....................... - 65 -
Figura 44– Comparação entre as Curvas .................................................................... - 68 -
Figura 45– Comparação entre os Dados do Arduíno e do Piranômetro ..................... - 68 -
Figura 46– Experimento para Levantamento da Curva de Calibração do Piranômetro- 69
-
xiii
Figura 47-Arquivo .txt de corrente ............................................................................. - 70 -
Figura 48-Arquivo .txt de radiação............................................................................. - 71 -
Figura 49-Arquivo .txt do GPS................................................................................... - 72 -
Figura 50-Arduíno MEGA ......................................................................................... - 73 -
Figura 51- Tablet Aakash, UbiSlate 7Cz .................................................................... - 77 -
Figura 52-Interface Piloto ........................................................................................... - 78 -
Figura 53- Interface Técnico ...................................................................................... - 79 -
xiv
Lista de Tabelas
Tabela 1-Especificações do Motor ......................................................... - 13 -
Tabela 2- Dados do Painel pelo Padrão STC - 1000W/m² .................... - 16 -
Tabela 3-Legenda Figura 11 .................................................................. - 17 -
Tabela 4- Correntes Máximas Dos Sistemas ......................................... - 22 -
Tabela 5– Legenda da Figura 15 ............................................................ - 23 -
Tabela 6– HDOP e sua Classificação..................................................... - 46 -
Tabela 7- Dados do sensor de corrente ACS758ECB-200B ................. - 53 -
Tabela 8– Características do Piranômetro ............................................. - 54 -
Tabela 9– Valores para Calibração ........................................................ - 63 -
Tabela 10– Valores para Calibração do sensor Piranômetro ................. - 67 -
- 1 -
Capítulo 1 – Introdução
1.1 Contexto
Nos últimos anos foi possível verificar um aumento do número de competições
realizadas entre universidades envolvendo veículos tripulados produzidos por alunos. Em
relação à UFRJ (Universidade Federal do Rio de Janeiro), pode-se destacar o Desafio
Solar Brasil, que utiliza barcos solares1 e a Fórmula SAE2, uma competição entre carros.
Em função deste aumento, a dificuldade e a competitividade entre os participantes está
cada vez mais acirrada, aumentando a importância de se analisar o desempenho dos
referidos veículos de forma qualitativa e quantitativa no intuito de aprimorar sua
performance.
Todas essas competições têm como objetivo estimular os estudantes a aprofundar
seus conhecimentos sobre as tecnologias atuais nos diversos segmentos de que
participam, bem como desenvolver novas tecnologias nestas áreas. Em especial, a área da
navegação solar visa estimular o desenvolvimento de tecnologias que utilizam fontes
alternativas de energia (como é o caso da geração solar fotovoltaica) para o transporte.
O que se pode observar no cenário mundial é uma tendência à substituição das
fontes convencionais de energia (como o petróleo) por novas fontes menos poluentes e
que sejam renováveis. No ambiente da UFRJ, mais particularmente na Ilha do Fundão,
onde se encontra o Centro de Tecnologia, pode-se destacar o desenvolvimento do ônibus
1 A principal competição da qual participa o barco solar do fundão é o Desafio Solar Brasil cujo o objetivo é estimular o desenvolvimento e divulgar a aplicação de fontes de energia alternativas em embarcações de serviço, recreio e transporte de passageiros. Mais informações podem ser encontradas no site do Desafio: http://desafiosolar.wordpress.com/. 2 É um desafio lançado aos estudantes de engenharia que tem como objetivo desenvolver e propiciar a difusão e intercâmbio de conhecimentos de Engenharia formula náutica. Mais informações podem ser encontradas no site da competição http://www.saebrasil.org.br/eventos/programas_estudantis/.
- 2 -
híbrido movido a hidrogênio 3 que pode ser visto na Figura 1. Este veículo foi
desenvolvido com tecnologia 100% nacional e busca uma solução real para o problema
da poluição gerada pelos atuais meios de transporte público urbano.
Figura 1- Ônibus Híbrido a Hidrogênio
Fonte: http://www.ufrj.br/mostranoticia.php?noticia=14786_Onibus-a-hidrogenio-da-
Coppe-reforca-transporte-da-Cidade-Universitaria.html
Saindo do ambiente da UFRJ e analisando as tecnologias de veículos movidos
com a energia solar, tem-se como exemplo um carro conceito desenvolvido pela Ford em
conjunto com a Georgia Institute of Tecnology, apresentado no International Consumer
Eletronics Show que ocorreu em Las Vegas, Estados Unidos, no começo de 2014.
Este carro híbrido é chamado de C-Max Energi Solar4 e pode ser observado na
Figura 2. É um carro elétrico que, ao invés de alimentar suas baterias a partir de uma
3 Para saber mais sobre esse ônibus, visitar a página: http://www.planeta.coppe.ufrj.br/artigo.php?artigo=1789 4 Para mais informações sobre esse novo conceito acessar a página: https://media.ford.com/content/fordmedia/fna/us/en/news/2014/01/02/let-the-sun-in--ford-c-max-solar-energi-concept-goes-off-the-gri.html.
- 3 -
tomada, utiliza uma lente especial chamada de Fresnel que concentra a luz nas células
solares, aumentando em até 8 vezes o seu impacto. Utilizando esse modelo, a Ford estima
que é possível reduzir em até 4 toneladas as emissões de gases de efeito estufa anuais em
comparação a um modelo tradicional.
Figura 2- Ford Modelo C-Max Energi Solar
Fonte:https://media.ford.com/content/fordmedia/fna/us/en/news/2014/01/02/let-the-
sun-in--ford-c-max-solar-energi-concept-goes-off-the-gri.html
Observando o que foi descrito, é possível confirmar a tendência mundial em
desenvolver novas fontes de energia que preservem o planeta.
Voltando às competições acima citadas que têm ajudado a desenvolver essa,
dentre outras tecnologias, será tratado neste projeto o barco solar do LAFAE 5
5 Para mais informações sobre o Barco Solar, ver seção 2.2 deste projeto.
- 4 -
(Laboratório de Fontes Alternativas de Energia), na UFRJ, que é utilizado no Desafio
Solar Brasil.
Os pesquisadores envolvidos com esse barco têm percebido que durante as
competições e testes, quem controla o barco solar a partir do cockpit possui pouca
informação sobre o andamento do mesmo (velocidade, direção de deslocamento), a
condição de carga de suas baterias, a geração fotovoltaica instantânea e consumo, dentre
outras indicações.
A falta de dados faz com que o piloto conduza o veículo “às cegas”, já que a
qualquer momento, uma falta de radiação solar adequada e um consumo excessivo do
sistema de armazenamento (banco de baterias) podem fazer com que o barco fique
impossibilitado de prosseguir, permanecendo à deriva e comprometendo todo o
planejamento da equipe ou até mesmo a segurança do piloto e da embarcação.
Outro problema relacionado à falta de informações técnicas durante e após uma
competição ou manutenção e preparação do barco é que, sem elas, fica difícil observar se
tudo está conforme a normalidade, seguindo as expectativas. Dados como energia
consumida pelo motor, energia gerada pelo sistema de geração, nível de carga do sistema
de armazenamento e radiação solar incidente, entre outros, podem servir de base para um
estudo mais detalhado das condições e comportamento do barco tanto durante a corrida
como durante sua preparação. Esses dados podem gerar gráficos comparativos
importantes que mostrem o comportamento de diversos componentes em diferentes
situações, tais como:
Se o motor está funcionando corretamente e não consumindo mais do que
o esperado;
- 5 -
Se o sistema de geração está aproveitando com boa eficiência a radiação
incidente, sem desperdiçar energia em excesso e ainda se as baterias
conseguem manter o seu nível de carga corretamente;
Se o piloto não está andando muito rápido e, por consequência,
consumindo energia demais em momentos de baixa insolação (isso se dá,
pois o consumo de energia varia de acordo com o cubo da velocidade,
seguindo a fórmula Pins=v³, onde Pins é a potência instantânea consumida
e v é a velocidade).
Esses problemas se apresentam devido à falta, na estrutura do barco, de um
sistema de auxílio à navegação mais completo, que possa ser usado para ajudar na tomada
de decisões por parte do piloto e da equipe em terra tanto durante como posteriormente à
corrida.
Esse projeto tem como meta resolver parte dos problemas apresentados,
auxiliando o desenvolvimento do barco solar como um todo.
Como comentado anteriormente, o foco deste projeto é o desenvolvimento de um
sistema de monitoramento e registro de dados de sensores para utilização no barco solar.
Este sistema de monitoramento tem a finalidade de registrar os dados dos sensores em
um cartão micro-SD que poderá ser analisado pela equipe após as corridas, facilitando,
assim, a detecção de problemas ou auxiliando na melhoria do desempenho do barco.
O intuito é que, através da implementação desse sistema de monitoramento e
registro de dados, seja possível coletar uma infinidade de dados relacionados aos sistemas
de geração e propulsão do barco que ajudarão na análise do seu desempenho, como, por
exemplo, o possível desperdício de energia de algum componente ou a sobrecarga de
algum dispositivo.
- 6 -
Esses dados são de extrema importância para uma equipe de competição e
desenvolvimento de tecnologias, já que, sem os mesmos, fica difícil analisar quais
sistemas do barco podem ou devem ser melhorados. Os dados permitem uma verificação
quantitativa e comparativa, possibilitando uma análise antes de determinada modificação
e depois da mesma.
1.2 Objetivo
O objetivo deste trabalho é propor um sistema de monitoramento e registro de
dados para apoio da navegação do veículo capaz de armazenar dados provenientes de
sensores distribuídos pelo barco e fazer um pré-processamento dos mesmos. Esse sistema
será então testado em bancada e será realizada a validação de alguns de seus componentes
Nesse projeto será desenvolvido o sistema de armazenamento, sua programação e
componentes, seus testes e validações. É ainda objetivo desse trabalho o desenvolvimento
de uma placa de interconexão de sensores que ligará os mesmos ao sistema de
armazenamento.
A parte da captação e armazenamento de dados foi desenvolvida utilizando-se a
plataforma microcontroladora conhecida como Arduíno, sendo nesta desenvolvidos os
programas necessários.
1.3 Metodologia
Este trabalho foi desenvolvido conforme as etapas abaixo:
1. Preparação do projeto descritivo do sistema de captação e telemetria de
dados.
- 7 -
2. Estudo da plataforma Arduíno, com o objetivo de aprender a programação
e compreender seu funcionamento. Realização de curso de treinamento e
revisão bibliográfica.
3. Programação de um sistema de aquisição de dados de sensor em Arduíno,
com testes práticos para validações.
4. Programação de um sistema de aquisição de informações de um GPS em
Arduíno, com testes práticos para validação.
5. Desenvolvimento e Construção de uma placa de interconexão entre
sensores e a placa Arduíno.
6. Teste da placa de interconexão e melhorias.
7. Aquisição dos dados dos sensores ligados a essa placa (sensor piranômetro
e sensor de corrente).
8. Levantamento da curva de calibração do piranômetro e sensor de corrente.
1.4 Organização
Este projeto está estruturado e organizado em um total de 5 capítulos além deste
capítulo introdutório.
No Capítulo 2, a concepção teórica do sistema de captação e armazenamento de
dados, já considerando uma futura ampliação que realize telemetria, é apresentada. É
ainda apresentada de maneira sucinta o conceito de Arduíno e seus Sensor Shields. Na
seção de telemetria são apresentadas ideias de interfaces e seus componentes.
O Capítulo 3 foca o desenvolvimento dos programas usados no sistema de
armazenamento e registro de dados. Especificam-se os programas desenvolvidos e suas
principais linhas de código assim como os testes realizados utilizando-se esses programas
e seus resultados.
- 8 -
No Capítulo 4 são descritos os sensores que foram utilizados nos testes
apresentando suas características e a sua possibilidade de utilização no barco real. É
discutida então a criação da placa de interconexão entre os sensores e o Arduíno,
explicando sua montagem e vantagens. Apresenta-se ainda o processo de levantamento
das curvas de calibração dos sensores presentes nessa placa mostrando seus resultados e
suas validações.
O Capítulo 5 apresenta de forma sucinta os resultados dos registros de dados,
mostrando como os mesmos se encontram armazenados no cartão SD. Neste mesmo
capítulo é discutida uma ampliação para o sistema.
O trabalho é então concluído no Capítulo 6 onde serão apresentadas as
considerações finais e ainda os temas para futuros trabalhos.
- 9 -
Capítulo 2 – Composição do Sistema
2.1 Introdução
Com o intuito de resolver alguns dos problemas apresentados no capítulo um, é
proposto então um sistema de monitoramento e registro de dados para apoio à navegação
do veículo solar a ser instalado no barco solar do LAFAE, capaz de captar e armazenar
os dados de uma série de sensores instalados no veículo. Este sistema irá permitir uma
análise dos dados armazenados posteriormente a uma corrida.
Este capítulo será iniciado com a descrição do barco solar do LAFAE com seus
principais componentes e sistemas de geração e propulsão especificando as suas partes
constituintes.
Na continuação do capítulo serão descritos os principais componentes que irão
compor o sistema de monitoramento e registro de dados a ser desenvolvido neste projeto,
apresentando suas principais funções e onde estarão dispostos no barco.
2.2 O Barco Solar
O barco solar é um veículo aquático cuja única fonte de propulsão é a energia
fornecida pelo Sol que é captada a partir de painéis solares instalados na proa do barco.
Esses painéis captam os fótons provenientes do Sol e os transformam em energia elétrica
através do silício presente nos painéis, utilizando o efeito fotovoltaico6.
O barco em si é formado por um casco feito de fibra de vidro no formato de um
catamarã possuindo um comprimento aproximado de 6,0 metros e uma largura
aproximada de 1,80 metros. O LAFAE construiu dois barcos, respectivamente
6 Efeito fotovoltaico é a criação de tensão elétrica ou de uma corrente elétrica correspondente em um material exposto a luz. [10]
- 10 -
denominados Mangue e Cajaíba, possuindo o mesmo formato e dimensões que são
padronizados pelas regras da competição. Na Figura 3 pode-se observar o formato do
casco.
Figura 3-Formato do Casco do Barco Mangue [1]
A Figura 4 é referente ao barco Cajaíba, porém como já foi dito possui o mesmo
formato do barco Mangue [1].
Figura 4-Vista lateral do Catamarã Mangue[1]
Atualmente o barco possui um sistema de propulsão formado por um motor do
fabricante Turnigy, modelo C80100-180, que pode ser visto na Figura 7, que é um motor
DC sem escovas (BLDC) e com rotor externo em torno do eixo e bobinas.
- 11 -
Os motores BLDC são definidos como motores rotatórios auto sincronizáveis
controlados por comutadores eletrônicos, onde o rotor é, normalmente, composto por
imãs permanentes com sensores de posição do rotor e o circuito de comutação relacionado
pode ser independente ou integrado ao motor (como pode ser observado na Figura 5) [15],
sendo os motores BLDC desenvolvidos com base nos motores DC sem escovas [15]. Para
se saber a posição angular do rotor, usa-se principalmente sensores de efeito Hall que
determinam se é o polo norte ou o sul do imã que está passando por esse sensor. Com o
sinal do sensor Hall, o inversor desliga ou liga as bobinas de modo apropriado para gerar
o torque necessário. Como o controlador de velocidade tem que ligar as bobinas de modo
a gerar o torque que é pedido, é necessário que um inversor envie uma corrente de sentido
correto para o motor (a forma dessa corrente é normalmente trapezoidal ou quadrada).
Com isso é necessário um inversor que seja capaz de enviar uma corrente de sentido
positivo em um momento e de sentido negativo caso seja necessário. Nesse caso, quando
se diz inversor, não é objetivo dizer que o mesmo produz uma corrente AC senoidal
(motores BLDC acionados por correntes senoidais são chamados de Motores Síncronos
de Imãs Permanentes ou PMSM em inglês [15]).
Figura 5-Topologia e Circuito Equivalente de um Motor BLDC [15]
- 12 -
Na Figura 6 pode-se observar um motor Turnigy durante sua operação (primeira
imagem do conjunto) e em repouso (segunda imagem do conjunto), mostrando sua
carcaça girante.
Figura 6-Imagem do Motor em Funcionamento e em Repouso
Fonte: https://www.youtube.com/watch?v=F_xTHZPwAKc
Figura 7-Motor C80100-180 Turnigy [1]
- 13 -
A Tabela 1 apresenta algumas informações obtidas no site do fabricante.
Tabela 1-Especificações do Motor
Modelo C80100-180
Potência Máxima 7000W
Resistência 17ohm
Corrente em Repouso 3,5 A
ESC 150 A
Máxima Tensão de Entrada 48V
Eixo 12mm
Intervalo de Tensão 20-48v
Corrente sem Carga 3,3 A
Equivalência 60-80cc Motor a Gasolina
Voltas Seis (6)
Kv (constante) 180 rpm/V
Peso 1812g
Outro dispositivo que compõe o sistema de propulsão é o ESC (Eletronic Speed
Controller) que pode ser visto na Figura 8. O mesmo é um circuito de potência que
funciona como um acionador do motor BLDC. Ele funciona como um inversor sendo que
seu microprocessador tem firmware7para controlar a comutação com ou sem sensores de
posição além de outras funções. Atualmente é usado o Phoenix Castle ICE HV 120
dedicado a aeromodelos [1]. É especificado para baterias de LiPo (LithiumPolimer) [1]
com tensão 12S, onde S representa células conectadas em série. Informações no site do
fabricante garantem correntes máximas de 120A e tensões máximas de 50V.
7Firmware é o conjunto de instruções operacionais programadas diretamente no hardware do equipamento eletrônico. É armazenado permanentemente em um circuito integrado de memória de hardware, como uma ROM, PROM, EEPROM no momento da fabricação do componente. Fonte: http://pt.wikipedia.org/wiki/Firmware
- 14 -
Figura 8-ESC do Motor [1]
Ainda na parte de propulsão, a mesma é formada por uma rabeta, cuja função é de
transferir o torque mecânico do motor para o hélice, conforme pode ser visto na Figura 9.
O torque é transferido do motor ao hélice através de engrenagens cônicas a 90°.
Figura 9-Conjunto Motor, Rabeta e Hélice [1]
Na Figura 9 é possível observar o conjunto Motor (indicado pela seta 1),
Transmissão (indicado pela seta 2) e Hélice (indicado pela seta 3).
- 15 -
O catamarã possui ainda um sistema de armazenamento formado por um banco
de baterias composto por três baterias em série, modelo Freedom DF300 12V e 26Ah (o
tipo de bateria pode ser visto na Figura 10), totalizando 936Wh de energia [1]
(Normalmente a capacidade de armazenamento de baterias é descrita em Ah, porém como
as regras da competição estipulam uma capacidade nominal máxima de armazenamento
de 1KWh, será deixado a informação no projeto em Wh).
Figura 10-Bateria Modelo Freedom DF300 12V
Fonte: http://www.solenerg.com.br/files/ManualTecnicoFreedom.pdf
Outra parte que compõe o barco é o sistema de geração caracterizado por um
conjunto de painéis solares. Na Etapa de Búzios, que foi uma das etapas do Desafio Solar
Brasil realizada em 2013, o barco trabalhou com painéis da Kyocera modelo KD240GH-
2PB cujos dados podem ser vistos na Tabela 2. O conjunto possui quatro painéis
arranjados em dois ramos em paralelo, cada qual com dois painéis em Série (2S2P),
fornecendo uma potência máxima de 960W, com máximos de 59,6V e 16,1A [1]. Vale
aqui ressaltar que os painéis solares são fornecidos pela organização do evento8.
8 Mais informações sobre as regras da competição podem ser encontradas em http://desafiosolar.files.wordpress.com/2008/09/regras-do-desafio-solar-brasil-2013.pdf
- 16 -
Tabela 2- Dados do Painel pelo Padrão STC - 1000W/m²
Potência Máxima 240W
Tensão no MPP 29,8V
Corrente no MPP 8,06A
Tensão de Circuito Aberto 36,9V
Corrente de Curto Circuito 8,59A
Eficiência 14%
Comprimento 1,67m
Largura 0,99m
Peso 21Kg
Outra parte que compõe o sistema de geração é o equipamento (conhecido como
MPPT) que realiza o controle de carga das baterias e o rastreamento do ponto de máxima
potência dos painéis. O MPPT analisa uma família de curvas I x V do painel e busca nessa
curva o ponto de máxima potência, esse equipamento busca regular a tensão e corrente
de operação dos painéis fotovoltaicos de modo a obter o máximo produto I x V [14]. O
equipamento utilizado é o Xantrex XM-MPPT60-150, que além de realizar o MPPT, faz
a conversão DC-DC, tipo Buck apenas (no caso do barco solar a tensão de saída dos
painéis é maior que a tensão do banco de baterias, por isso é necessário apenas um
conversor abaixador de tensão), para a tensão das baterias. [1]
Por fim, o esquema elétrico do barco pode ser visto na Figura 11, sendo a Tabela
3 a legenda dessa Figura.
- 17 -
Tabela 3-Legenda Figura 11 [1]
Figura 11-Esquema Atual de Propulsão e controle [1]
Sigla Funcionalidade
PV Painel Fotovoltaico
MPPT Maximum Power Point Tracker
D1 Disjuntor
F1 Fusível
Vs Banco de Baterias
ESC Electronic Speed Controller
S1 Chave On/Off
S2 Chave de Iluminação
S3 Chave da Bomba de Porão Bombordo
S4 Chave de Bomba de Porão Boreste
DMS1 Contatora
DMS2 Chave Corta Corrente
DMS3 Relé da Contatora DMS1
FA1,2,3,4 Fonte Auxiliar
BPb,BPe Bombas de Porão
Controle Placa de Controle
LA Luz Auxiliar
LBb Luz Bombordo
LBe Luz Boreste
M Motor
- 18 -
2.3 Componentes do sistema
O sistema será composto basicamente de duas partes. Os sensores ligados às partes
mais importantes do barco (motor, painéis solares e banco de baterias) e um dispositivo
de concentração e armazenamento de dados.
2.3.1 Sensores
Os sensores são a primeira parte do sistema a ser descrito. São eles que permitirão
captar os dados para que depois possam ser processados. O objetivo é utilizar sensores de
corrente e tensão ligados aos painéis solares, sensor de tensão ligado ao banco de baterias
e sensores de corrente ligados ao motor.
Para os painéis, como sua geração é em corrente contínua, devemos utilizar um
sensor de corrente DC a ser ligado em série com o circuito das placas solares. A corrente
ao passar por ele, faz com que o sensor produza um sinal de tensão correspondente ao
nível de corrente por ele captado. Um típico sensor de corrente da AllegroMycrosystems
pode ser observado na Figura 12, sendo que esse sensor está explicado mais a fundo no
subcapítulo 4.2.1 deste trabalho. Esse sensor estará então conectado ao dispositivo
concentrador de dados por meio de uma placa projetada para fazer a interconexão. O
objetivo de se utilizar uma placa para a interconexão é de se garantir uma boa estabilidade
mecânica para os terminais da fiação proveniente dos sensores, de modo a evitar ao
máximo qualquer falha por mau contato.
Figura 12- Sensor de Corrente Allegro
- 19 -
Fonte: http://www.electronicspecifier.com.br/sensores/sensor-de-
corrente-da-allegro-e-termicamente-aperfeicoado-para-atingir-alta-precisao
Nos painéis, é ainda necessário utilizar um sensor de tensão, para que seja possível
calcular-se a tensão gerada por eles. Assim como o de corrente, o sensor de tensão produz
um sinal de saída proporcional à tensão aplicada em seus terminais de entrada, porém
reduzindo neste caso seu nível ou amplitude, para que possa ser conectado a dispositivos
eletrônicos de baixa tensão. Um exemplo de sensor de tensão pode ser observado na
Figura 13. No trabalho aqui descrito não foi utilizado nenhum sensor de tensão, pois os
mesmos não encontravam-se disponíveis no laboratório. Para substituí-los nos testes
foram usados divisores de tensão resistivos, onde o potenciômetro tinha suas
extremidades ligadas uma no pino terra e outra no pino 5 V do Arduíno, e seu pino de
resistência variável foi conectado em uma entrada analógica conveniente do Arduíno. Os
potenciômetros utilizados foram de 5 KΩ sendo que aguentavam até 5 W de potência.
Para o trabalho não era necessário um potenciômetro tão robusto quanto o utilizado já
que a corrente máxima nos pinos de saída Arduíno é de 40 mA e a tensão utilizada nos
experimentos foi de 5V, com isso um potenciômetro de 200 mW seria suficiente. A
utilização do potenciômetro mais robusto nos experimentos (de 5W) foi meramente
devido a sua disponibilidade no laboratório.
Esse sensor será ligado ao dispositivo de concentração de dados através da mesma
placa projetada para fazer a interligação do sensor de corrente, aproveitando suas
vantagens de conexão.
- 20 -
Figura 13-Sensor de Tensão
Fonte: http://www.phidgets.com/products.php?product_id=1123
Devido às limitações do Arduíno utilizado, será omitida a aplicação do sensor de
corrente ligado às baterias, isso porque essa corrente pode ser estimada a partir das
demais, como podemos observar na Figura 14. Como é possível calcular a corrente Ip
(corrente das placas solares após passar pelo MPPT) utilizando o sensor de corrente ligado
aos painéis e a corrente Im (corrente que irá para o motor antes do ESC) utilizando o
sensor de corrente ligado ao ESC, o cálculo de Ib (corrente que vai para o banco de
baterias) se torna simples.
Figura 14-Diagrama de Correntes
- 21 -
Com isso será conectado a elas apenas um sensor de tensão DC, porém esse sensor
deverá ser sensível a ponto de captar pequenas variações na tensão, isso porque sabe-se
que a carga armazenada nas baterias se relaciona com a tensão de seus terminais.
Sabe-se que nas baterias de chumbo-ácido de 12 V sua tensão não deve cair abaixo
de 10,8 V (limite inferior de 1,8 a 2,1 V por célula em uma bateria de 6 células [14]) e
nem passar de 13,8 V (limite superior de 2,3 a 2,5 V por célula em uma bateria de 6
células [14]). Com isso em mente, um modelo que poderia ser utilizado para fazer uma
relação entre a carga presente nas baterias com sua tensão seria relacionar a tensão da
bateria com uma porcentagem (por exemplo 13,8 V sendo 100 % e 10,8 V sendo 0%) e
utilizar essa relação para estimar a situação de carga da bateria. O ideal é que essas
medições sejam feitas à temperatura ambiente, entre 25 C° e 27 C° (temperaturas mais
baixas reduzem significativamente suas capacidades, e temperaturas mais altas aumentam
ligeiramente sua capacidade, porém reduzem o número de ciclos de sua vida útil [14]).
Este não é um modelo ideal (o modelo mais preciso necessitaria de um densímetro e um
acesso na bateria para se captar a solução da mesma), porém satisfaz as necessidades do
projeto podendo ser aplicado no barco solar.
Esse sensor de tensão, como os descritos acima, deverá ler a tensão em seus
terminais e transforma-la em um sinal de tensão. Ele será ligado em paralelo com o
circuito das placas.
No motor também será utilizado um sensor de corrente DC (para ilustrar, um tipo
de sensor pode ser observado na Figura 13) isso porque o sensor se encontrará do lado
DC do controlador ESC que aciona o motor. Esse sensor será ligado em série com o
circuito de alimentação do motor. Será, então, ligado ao dispositivo concentrador de
dados através de uma placa de interconexão. Seu funcionamento, como o dos outros
sensores acima descritos, se baseia na transformação da corrente que passa por ele em um
- 22 -
sinal proporcional de tensão. Na Tabela 4 pode-se observar uma estimativa das correntes
que os sensores de corrente deverão ser capazes de suportar.
Tabela 4- Correntes Máximas Dos Sistemas
A estimativa de corrente do sistema de propulsão foi baseada em medições feitas
durante a operação do barco. Nelas a corrente máxima alcançada foi de 90 A.
Essa Tabela 4 justifica a escolha dos sensores utilizados posteriormente nos testes,
bem como os sensores serão instalados no barco.
Utilizando-se o sensor de corrente ligado ao motor e aproveitando-se a leitura do
sensor de tensão ligado ao banco de baterias, pode-se calcular a potência consumida pelo
sistema de propulsão. Com esse dado e também o dado da potência gerada pelo sistema
fotovoltaico e a energia armazenada no banco de baterias, é possível fazer um balanço
energético e saber se esse balanço é positivo ou negativo. Esse balanço é de extrema
importância para o piloto já que informa se o barco tem capacidade de concluir a corrida
com o atual consumo x geração.
A Tabela 5 apresenta legendas da Figura 15 auxiliando em seu entendimento. A
Figura 15 mostra as disposições dos sensores no circuito de alimentação e propulsão do
barco.
Corrente Máxima
Arranjo Fotovoltaico 17,18 A
Sistema de Propulsão 90 A
- 23 -
Tabela 5– Legenda da Figura 15
Legenda
PV Arranjo Fotovoltaico
M Motor
MPPT Maximum Power Point Tracking
D1 Disjuntor
F1 Fusível
Vs Banco de Baterias
Sa1 Sensor de corrente ligado aos painéis
Sa2 Sensor de corrente ligado ao motor
St1 Sensor de tensão ligado aos painéis
St2 Sensor de tensão ligado as baterias
Arduíno / Shields
Representa o Dispositivo Concentrador e Armazenador de Dados
Figura 15– Diagrama dos Sensores se Conectando ao Dispositivo Concentrador
de Dados
- 24 -
O último sensor a ser conectado é o piranômetro. Piranômetro é um sensor
utilizado para medir a radiação solar, sendo sua unidade o Watt por metro quadrado (𝑊
𝑚²).
Esse sensor deverá ser alocado próximo às placas solares de modo a captar a mesma
radiação que está incidindo sobre as mesmas. O funcionamento desse sensor é análogo
ao dos sensores acima descritos, a radiação incidente sobre o aparelho é transformada em
um sinal de tensão onde a cada variação desse sinal de tensão corresponde a uma variação
na radiação incidente. A conexão desse aparelho com o dispositivo de concentração de
dados se dará através de uma placa de interconexão. A importância desse piranômetro é
servir de referência para a potência elétrica produzida pelos painéis. Apesar das placas
solares não transformarem toda a radiação incidente em energia, e de haver perdas no
circuito como um todo, é possível observar se as perdas estão ou não dentro de um nível
aceitável, e em caso negativo, possibilitar o reparo do componente responsável por essa
perda.
2.3.2 Dispositivo de Concentração e Armazenamento de Dados
O objetivo desse dispositivo é ser um centro de concentração de dados e
armazenamento. Além disso será um primeiro centro de processamento desses dados e
servindo ainda para, futuramente, transmitir esses dados. Os sensores enviarão dados a
todo o momento, e esse dispositivo será responsável por processar esses pacotes de
informações e armazenar em arquivos dentro de um cartão micro-SD.
Esse centro de concentração de dados será composto por:
Uma placa Arduíno que receberá todas as informações e realizará os
cálculos e armazenamentos necessários;
O Shield GPS - que servirá para dar informações como velocidade, direção
de deslocamento, entre outras;
- 25 -
A placa de interconexão entre os sensores e o Arduíno e
O dispositivo de comunicação serial sem fio que conectará o Arduíno com
o dispositivo móvel que estará nas mãos do piloto.
Os sensores enviarão a todo momento dados para o Arduíno e caberá ao programa
desenvolvido para ele interpretar os diversos sinais de tensão provenientes dos sensores
obtendo o valor real da leitura deles, além de armazená-los em um arquivo para posterior
análise. É ainda nesse dispositivo que ocorrerão os processamentos necessários para se
calcular as potências geradas e consumidas além da energia armazenada nas baterias.
Como dito acima, é esse dispositivo que será o responsável pelo armazenamento
dos dados. Esse armazenamento será realizado em uma mídia externa que para esse caso
será um cartão micro-SD. Esse armazenamento é de extrema importância já que a análise
dos dados após as provas pode mostrar se há algum problema ou algum ponto a se
melhorar no barco.
Será carregado no microcontrolador do Arduíno um programa que permitirá a ele
fazer a leitura e converter as informações dos sensores em dados reais, fazer os cálculos
para se obter a informação necessária à análise, assim como obter os dados do GPS. Além
disso, é o programa que será responsável por enviar essas informações tanto para o SD
responsável pelo armazenamento como para o dispositivo móvel.
A placa de interconexão dos sensores servirá para facilitar o acesso das diversas
conexões caso seja necessário. A placa desenvolvida até o momento servirá apenas de
teste, pois ainda não se sabe se esta configuração é a ideal.
É importante salientar que todo esse sistema deverá se encontrar em um ambiente
a prova d’água de modo a evitar curtos e falhas dos equipamentos. O ideal é que se
encontrem em uma caixa vedada com uma proteção IP 56 ou mais. Como exemplo de
caixa temos a caixa hermética termoplástico da marca HYPERSAT (como pode ser visto
- 26 -
na Figura 16) que possui várias dimensões para escolha o que possibilitaria a aquisição
de uma ideal para a necessidade apresentada além de apresentar uma proteção de IP9 56.
Figura 16-Caixa Hermética da Hypersat
Fonte:http://www.sat5.com.br/produtos.php?codigo=000844
A placa de Arduíno a ser utilizada depende do número de sensores a serem ligados
e da necessidade de memória de programação para realizar todos os processamentos
exigidos pelo sistema.
Por fim, outro objetivo desse dispositivo será o envio dos dados em tempo real
para um programa instalado em um dispositivo móvel que fará a interface entre dados e
piloto. Esta transmissão se dará sem fio através de protocolo Bluetooth ou Wireless
2.3.2.1 Arduíno e Shields
Arduíno é uma ferramenta desenvolvida de modo a fazer com que computadores
possam controlar os objetos fisicos. É uma plataforma física de computação open-
9 Esse Código de Proteção IP classifica e gradua o grau de proteção de um invólucro de um equipamento elétrico – eletrônico. Mais informações podem ser encontradas em http://www.chrompack.net/index.php?page=ip
- 27 -
source10 baseada numa simples placa microcontroladora e um ambiente de programação
para ligar o software produzido à placa. Possui um microcontrolador da ATMEL sendo
seu modelo variável de acordo com a placa utilizada [11].
Arduíno pode ser usado para desenvolver objetos interativos, receber dados de
uma variedade de sensores e chaves e controlar uma variedade de luzes, motores e outros.
Sua confecção foi feita de modo a ser bem amigável ao usuário, sendo que apresenta
impressa na própria placa informações importantes tais como quais os pinos de entrada e
saída analógicos, quais os digitais, entre outras informações [11].
Os projetos Arduíno podem rodar sozinhos ou se comunicar com outros
programas que estejam rodando no computador, como por exemplo o Flash, MaxMSP,
entre outros [11].
Suas placas podem ser montadas à mão ou compradas pré-montadas como pode
ser vista na Figura 17 sendo que o ambiente de programação, o Arduíno IDE, pode ser
baixado de graça do site dos desenvolvedores do Arduíno11 [11].
Figura 17-Placa da família Arduíno
10 Plataformas open-source podem ser utilizadas e modificadas por qualquer um sem problema de direitos autorais e intelectuais. 11 www.arduino.cc
- 28 -
Fonte: http://www.techtudo.com.br/noticias/noticia/2013/10/o-que-e-um-arduino-
e-o-que-pode-ser-feito-com-ele.html
Existem várias outras plataformas microcontroladoras como por exemplo o
Parallax Basic Stamp, Netmedia’s BX-24, Phidgets, entre outras. Porém o Arduíno
apresenta muitas vantagens em relação a essas plataformas, como:
É mais barato se comparado às outras;
A plataforma Arduíno roda em vários sistemas operacionais, como Windows,
Linux e Macintosh OSX;
O ambiente de programação é fácil de usar para iniciantes, porém complexo o
suficiente para o desenvolvimento de projetos avançados;
Por ser Open-Source possui uma grande quantidade de bibliotecas e exemplos
espalhados pela WEB, assim como vários fóruns de dúvidas; e
Por ser Open-Source possui vários Shields já criados ou em processo de criação
que adicionam diversas funcionalidades ao Arduíno;
Os Arduíno Shields são adaptadores feitos para serem acoplados às placas Arduíno,
como se pode observar na Figura 18, de modo a adicionar funcionalidades a elas. São
placas plug-and-play, com conectores montados para serem acoplados às placas Arduíno.
Cada Shield tem uma característica própria e adiciona esta funcionalidade à placa
Arduíno principal. É possível acoplar vários Shields, uns sobre os outros na placa Arduíno
principal adicionando, assim, uma série de características a ela [11].
- 29 -
Figura 18- Shields Acoplados no Arduíno
Fonte: http://www.robotshop.com/en/arduino-compatible-mega-motor-
shield-1a-5-28v.html
Existe uma grande variedade de placas Arduíno onde as principais diferenças
entre elas são o microcontrolador utilizado e o número de entradas e saídas analógicas e
digitais. A escolha adequada do tipo de Arduíno deve basear-se nesses detalhes.
- 30 -
Capítulo 3 –Programação do Arduíno
3.1 Introdução
O Objetivo desse capítulo 3 é mostrar como foi desenvolvida a programação do
sistema de monitoramento e armazenamento de dados. Serão apresentados os programas
desenvolvidos, mostrando suas principais funcionalidades e a lógica de programação dos
mesmos através de fluxogramas.
Apesar de serem apresentados testes de bancadas que buscavam validar os
programas, o foco desse capítulo é a programação da plataforma Arduíno, sendo inclusive
apresentado e descrito nesse capítulo o tipo de placa da família Arduíno disponibilizada
no laboratório e na qual foi desenvolvido o trabalho.
O capítulo é iniciado com a apresentação da placa da família Arduíno utilizada e
seu ambiente de programação. Segue no capítulo a descrição do programa base
desenvolvido, seu fluxograma, seu teste e validação. A seguir apresenta-se o programa
completo de aquisição, seu teste e validação. Termina-se o capítulo com a descrição do
Shield GPS utilizado, o programa desenvolvido para captar e armazenar os dados dele,
seu fluxograma, teste e validação.
3.2 Arduíno UNO
Como dispositivo concentrador de dados e armazenador, foi escolhido o Arduíno
UNO que é uma placa da família Arduíno (já explicada no Capítulo 2).
O Arduíno UNO é na verdade a última versão das placas Arduíno básicas até esta
data. Ele trabalha com um microcontrolador ATMEGA 328 e possui as mesmas
- 31 -
características que sua predecessora, o Arduíno Duemilanove. A grande diferença para as
versões anteriores é que, ao invés de usar um FTDI para conversão RS232-USB (como
suas antecessoras), ela utiliza o ATMEGA8 (um outro microcontrolador), programado
para a conversão USB-serial. Com essa nova implementação, o arquivo de carregamento
do sistema diminuiu de tamanho, economizou memória flash no ATMEGA328 e, dessa
forma, contribuiu para a aceleração do processo [4].
O ATMEGA 328 é um microcontrolador que possui 32 Kbytes de memória Flash
de programação, 2 Kbytes de SRAM12 e 1 Kbyte de EEPROM13. É um microcontrolador
que opera com uma tensão de 5 Volts [4].
UNO significa um em italiano e é nomeado para marcar o lançamento do Arduíno
1.0. O Arduíno UNO (ou 1.0) será, a partir de então, a versão de referência (mais básica)
do Arduíno [4].
É importante ressaltar que o Arduíno UNO já passou por algumas revisões,
encontrando-se hoje em sua terceira revisão.
12 A memória SRAM armazena dados temporários. 13 A memória EEPROM armazena dados permanentemente só sendo apagados caso o programa
sobrescreva os mesmos.
- 32 -
Figura 19- Arduíno UNO [4]
Como se pode observar na Figura 19 o Arduíno UNO é uma placa bem completa,
algumas de suas características são [4]:
Portas 0 e 1 - São pinos I/O de comunicação serial com a placa (Pinos Rx e Tx).
Portas 2 a 13 – São Portas I/O digitais onde sua saída será somente 0 V ou 5 V
dependendo do código. As portas que possuem um til (~) do lado (portas 3, 5, 6, 9, 10 e
11) são as 6 portas onde estão disponíveis os canais PWM da placa.
Portas Analog In (A0 a A5) - São as 6 portas analógica disponíveis na placa. São portas
que possuem a conversão A/D de 10 bits de precisão, sendo assim possuem até 1024
níveis de tensão diferentes (vai de 0 a 1023).
Portas de Potência – Possuem pinos de alimentação externa de 5 V e 3,3 V, pinos terra
(GND) e um pino de reset externo.
- 33 -
Adaptador de entrada para Fonte - É uma entrada Jack para uma fonte de alimentação
externa que não seja o USB. Apesar da placa funcionar com alimentação de 5 V, devido
ao regulador de tensão existente na placa, a faixa de tensão de alimentação considerada
ideal é de 7,5 V a 10 V, sendo a tensão máxima suportada de 15V.
Entrada USB – É a entrada utilizada para a comunicação e carregamento do programa
no microcontrolador do Arduíno. Serve também como alimentação da placa já que o USB
do computador fornece uma tensão de 5 V estável.
3.3 Arduíno IDE
O software Arduíno IDE (Integrated Development Environment ou Ambiente de
Desenvolvimento Integrado) foi desenvolvido para ser o mais simples e intuitivo possível,
facilitando assim a programação por qualquer um que deseje utilizar placas Arduíno em
seus projetos. Esse software serve para qualquer uma das placas Arduíno e até mesmo
para placas similares a Arduíno, como a Freeduíno, entre outras.
O Arduíno IDE é uma plataforma multitarefa escrita em JAVA e baseada no
projeto Wiring 14 . Como foi dito, foi criada para pessoas não familiarizadas com
programação, de maneira a ser o mais intuitiva possível. Nela é possível desenvolver
programas para as placas, salvar esses programas, compilá-los, modificá-los e verificar
se os mesmos estão corretos. Além desses recursos, é através dela que se carrega o
bootloader15 em um novo chip microcontrolador.
Outra característica da plataforma é a presença de um monitor serial que mostra a
interação, caso esse comando esteja presente no programa carregado à placa, entre a placa
Arduíno e o computador. Com o monitor serial ainda é possível interagir com o programa
14 Plataforma de prototipagem que incluía tanto uma interface amigável como uma placa de circuito pronta para ser usada, desenvolvido por Hernando Barragán. 15 É um pequeno programa carregado no microcontrolador da placa que permite rodar os códigos Arduíno sem nenhum hardware externo.
- 34 -
enquanto o mesmo está rodando na placa, caso dentro dele exista um código para a leitura
de teclado.
O Arduíno IDE vem com uma série de programas exemplo e modelo já carregado
nele sendo apenas necessário executá-los e compilá-los para a placa. A grande vantagem
disso é que já existe uma boa gama de programas embutidos na plataforma de modo que
é possível basear-se neles para o desenvolvimento de um programa próprio.
Na figura 20 pode-se ver a tela inicial do Arduíno IDE com suas principais funções
destacadas
Figura 20-Tela inicial do Arduíno IDE com funcionalidades destacadas
3.4 Programa Base de aquisição de Dados
O primeiro passo para desenvolver o sistema de aquisição e armazenamento de
dados é criar um programa base na plataforma Arduíno capaz de captar dados de um
sensor qualquer e armazená-los em um cartão SD. O objetivo de se criar um programa
base e não diretamente o programa a ser utilizado é observar se todas as funcionalidades
- 35 -
esperadas de tal programa estão sendo corretamente efetuadas. Uma vez que se tenha
plena certeza de que o programa base funciona sem qualquer problema, pode-se então
fazer uma ampliação do mesmo para ser utilizado com um número maior de sensores.
O fluxograma do programa base é como se segue na Figura 21:
- 36 -
Figura 21- Fluxograma do programa Base
- 37 -
A parte de programação pode ser vista no anexo I. No caso do programa base são
encontradas algumas características que serão utilizadas pelos próximos programas. Uma
vez compilado para o Arduíno, liga-se o monitor serial para observar o andamento. Vale
lembrar que deve-se abrir o monitor serial na velocidade de comunicação escolhida na
programação.
O primeiro passo é observar na janela do monitor serial se a inicialização ocorreu
corretamente. Como o objetivo desse programa é captar e armazenar dados de um sensor
em um cartão micro-SD, o principal problema que pode ocorrer é uma falha de detecção
do dito cartão ou um problema de inicialização do mesmo (problemas com o código são
informados pelo Arduíno IDE durante a compilação). Caso isso ocorra a mensagem “Erro
ao iniciar cartão SD” aparecerá na tela do monitor serial e o programa travará. Para
solucionar o problema deve-se observar se o cartão realmente está colocado na placa.
Caso esteja retire-o e coloque novamente. Depois é só apertar o botão de Reset presente
na placa do Arduíno e esperar a reinicialização.
Caso tudo tenha ocorrido corretamente, a mensagem “inicialização OK” aparecerá
e tudo estará pronto para continuar.
Depois da “inicialização OK”, o programa entra em um modo que espera um
comando do usuário. É possível então a escolha de 4 letras cada uma levando a uma parte
distinta do programa.
Ao selecionar a tecla “c” (de configuração) o usuário entra em um modo de
configuração, onde é possível escolher de quantos em quantos segundos será feita a leitura
do sensor.
O objetivo dessa configuração é em função da necessidade de duas interfaces, uma
para o piloto e outra para um técnico. Para a interface do técnico, quanto maior a
disponibilidade de dados, melhor para uma posterior análise e regulação do barco. Assim
- 38 -
uma configuração de 1 segundo talvez seja um exemplo que cumpra os requisitos. Para a
interface do piloto que apenas está interessado na relação geração x consumo e também
no nível de carga das baterias, já que está preocupado com o desenrolar da prova que
compete, uma configuração de 3 segundos ou mais seja suficiente.
É bom esclarecer ainda que o valor em segundos será salvo na memória EEPROM,
assim uma vez que qualquer valor seja salvo, o mesmo permanecerá lá independente de
se desconectar o Arduíno de uma fonte de alimentação. Caso se queira alterar o valor, o
operador deverá sobrescrevê-lo na tela de configuração.
Ao selecionar a tecla “w” (de write) o usuário permitirá que o programa comece
a ler os dados do sensor a ele ligado e a armazená-los no micro-SD. Essa função do
programa trabalhará em loop de acordo com o intervalo de tempo escolhido na
configuração. Para sair do modo de leitura de dados, deve-se apertar a tecla “x” que
somente tem utilidade nesta parte da programação.
Pode-se ainda selecionar a tecla “r” (de read) de forma a fazer o programa mostrar
no monitor serial os dados que estão armazenados no cartão SD.
A última tecla funcional do programa é o “e” (de erase) que serve para apagar os
dados armazenados no cartão SD. A razão dessa tecla é a possibilidade de se apagar e
recomeçar leituras diferentes sem ter que sobrescrevê-las em um mesmo arquivo.
A razão de todas essas teclas é a possibilidade da pessoa que está no cockpit
controlar a aquisição dos dados.
Um exemplo da utilidade dessa configuração é o caso da necessidade de se refazer
os testes. O técnico responsável pode observar os dados até então armazenados ao apertar
“r”, conferindo se realmente há a necessidade de uma nova aquisição dados. Nesse caso,
do próprio cockpit, pode apagar os dados armazenados com o “e”, retomando
- 39 -
posteriormente a aquisição dos dados com o “w” ou até mesmo mudando o tempo de
aquisição do sensor com o “c”.
3.4.1 Teste preliminar do Programa 1
Para se testar o programa, foi conectado um potenciômetro ao Arduíno de modo
que o mesmo sirva de divisor de tensão. O Arduíno lê a tensão proveniente do
potenciômetro e armazenaria esses dados no micro-SD. O modo de conexão com o
Arduíno UNO pode ser visto nas Figuras 22 e 23:
Figura 22– Esquemático do teste do Programa 1
Uma representação de como foi feito o teste pode ser observada na Figura 23:
- 40 -
Figura 23– Representação do Teste 1
Nesse teste ainda foi usado um Ethernet Shield para Arduíno, pois o mesmo possui
uma entrada para cartão micro-SD.
3.5 Programa Completo de Aquisição de Dados
Para esse programa, que poderá ser encontrado no anexo II, não há necessidade
de apresentar um fluxograma já que seria o mesmo apresentado na Figura 21. As maiores
diferenças nele são a programação adaptada para três sensores em vez de um, pequenas
mudanças na programação para se adaptarem à placa de sensores produzida16 e aos
próprios sensores.
A principal adaptação feita neste programa e que merece uma atenção especial foi
a ampliação do mesmo, até então produzido para apenas um sensor, para um total de três
sensores. Essa ampliação é de extrema importância, pois como foi descrito nos capítulos
16 Essa placa de sensores será detalhada no próximo capítulo.
- 41 -
anteriores, serão necessários diversos sensores para que seja possível a captação de todos
os dados necessários. A ampliação feita para três sensores pode ainda ser aumentada para
um número maior sendo esta ampliação inicial uma demonstração da capacidade do
programa em ser ampliado.
3.5.1 Teste Preliminar do Programa 2
O teste desse programa foi similar ao teste do programa um, sendo as únicas
diferenças a utilização de três potenciômetros ao invés de um e a conexão em distintas
entradas analógicas do Arduíno.
Nas Figuras 24 e 25 são mostrados os esquemas de ligação. Apesar de somente
aparecer um potenciômetro nesse esquemático, ele está representando os três utilizados,
como poderá ser observado nas Figuras 25.
Figura 24– Esquemático do teste do programa
- 42 -
Figura 25- Representação do Teste 2
3.6 Programa de Aquisição de Dados do GPS
Após o desenvolvimento dos programas para a captação dos dados dos sensores,
foi desenvolvido um programa para a captura dos dados de um Shield GPS para Arduíno.
O Shield em questão é produzido pela ITEAD Studio.
3.6.1 Shield GPS ITEAD Studio
O Shield GPS ITEAD Studio é um Shield que adiciona ao Arduíno um receptor
GPS com armazenamento SD, permitindo o armazenamento de posições geográficas
entre outras informações no SD. [9]
Esse Shield é baseado no módulo GPS u-blox NEO-6M. Esse chip contém
múltiplos receptores GPS o que permite um posicionamento mais acurado, sendo útil para
várias aplicações como [9]:
Navegação automotiva;
- 43 -
Posição pessoal;
Navegação Marítima.
As principais vantagens desse Shield são:
Interface para micro-SD;
Saída para encaixe de antena de alta sensibilidade;
Temperatura de operação de – 40ºC à +85ºC; e
Rápida localização de sina.
Esse Shield supre todas as necessidades do projeto, principalmente devido a saída
que possui para acoplamento de antena. Deve-se levar em consideração que o GPS precisa
de uma visão do céu (total ou ao menos parcial) para que possa captar as informações do
satélite. É ainda importante lembrar que, na aplicação proposta, o mesmo deverá ficar
dentro de uma caixa protetora localizada no casco do barco. Devido a essas dificuldades,
a utilização de uma antena é algo imprescindível.
Na Figura 26 é possível ver um diagrama de layout desse GPS Shield.
Figura 26– Diagrama de Layout do GPS Shield [9]
- 44 -
Na Figura 27 podemos ver uma imagem do Shield com sua antena acoplada, e
ambos conectados ao Arduíno.
Figura 27– ITEAD GPS Shield e Antena [9]
3.6.2 Desenvolvimento do Programa
O fluxograma desse programa (que é possível de ser observado na Figura 28) é
bem parecido com o primeiro fluxograma apresentado, sendo seu programa disponível
no anexo III. Os botões utilizados no programa são os mesmos, tendo as mesmas funções
já apresentadas, onde em vez de armazenar dados de sensores, ele armazena dados do
GPS.
- 45 -
Figura 28– Fluxograma GPS
- 46 -
Os dados escolhidos para serem captados pelo GPS, mostrados e armazenados
foram:
O número de satélites dos quais o Shield está recebendo informações;
HDOP (Horizontal Dilution of Precision) indica a qualidade dos resultados
que podem ser esperados do GPS;
Tabela 6– HDOP e sua Classificação
Valor do HDOP Classificação dos Resultados
1 Ideal
2 Excelente
de 3 a 5 Bom
de 6 a 10 Moderado
de 11 a 20 Aceitável
>20 Fraco
Latitude da posição em graus;
Longitude da posição em graus;
Data;
Horário, sendo o mesmo o horário UTC devido a biblioteca usada;
Altitude;
Direção de deslocamento; e
Velocidade de Deslocamento.
O maior problema encontrado no desenvolvimento desse primeiro programa foi
com relação ao bitrate17. O chip u-blox módulo GPS que está presente no Shield GPS
ITEAD Studio trabalha com uma taxa de comunicação de 38.400 bps, porém a velocidade
máxima que o Arduíno pode trabalhar é de 19.200 bps (devido a utilização da biblioteca
SoftwareSerial 18 ). Assim foi preciso descobrir um meio de ajustar a velocidade de
17 Bitrate representa uma unidade de transferência de dados em bps (bits por segundo). 18 Biblioteca do Arduíno que permite a comunicação serial com uma série de pinos digitais, precisando só escolher os mesmos.
- 47 -
comunicação do u-blox para uma compatível com o Arduíno. Esse problema foi resolvido
com linhas de código que alteravam a velocidade de comunicação do GPS Shield para
4.800 bps, sendo esta a velocidade mais apropriada para a biblioteca SoftwareSerial [12].
Outro problema que é encontrado por muitos usuários é a demora para captação
inicial de dados, sendo que pode demorar entre 40 minutos e 1 hora para que o programa
consiga captar informações na primeira vez que é ligado (entende-se por essa primeira
vez a primeira utilização ao se tirar o Shield de sua caixa). Esta demora é importante, pois
mesmo após esse tempo o programa carregado no Arduíno pode não gerar a captação dos
dados (devido a programação, apesar de correta, não funcionar para esse Shield). Com
isso, após a 1 hora, caso não se tenha resultados, é necessário mudar a programação e
repetir o processo, sendo que isto demanda um longo tempo (no caso desse projeto a
demora para a captação das primeiras informações demorou em torno de 6 horas devido
a, também, problemas na programação). Da segunda utilização do GPS Shield em diante
a velocidade de captação de dados se mostra bem superior, sendo da faixa de 5 minutos
para a captação inicial de dados.
3.7 Programa para Captação de dados dos Sensores e GPS.
Este é o programa final, que junta o programa de aquisição de dados completo
com o programa de captação de dados do GPS, sendo sua programação encontrada no
anexo IV. Seu fluxograma é como o demonstrado na Figura 29, bem parecido com o
fluxograma já apresentado na Figura 28, porém com um bloco a mais representando a
leitura dos dados do GPS.
- 48 -
Figura 29– Fluxograma do programa completo
- 49 -
Apesar do programa ter sido desenvolvido e se conseguir compilar o mesmo
corretamente para o Arduíno, o mesmo não roda corretamente.
O programa inicia corretamente, porém ao tentar captar os dados dos sensores e
do GPS o mesmo trava e reinicia. Isso ocorre possivelmente devido a capacidade de
processamento que o Arduíno UNO apresenta, sendo que o mesmo não é capaz de
processar tantas informações diferentes ao mesmo tempo como dados de três sensores e
mais os vários dados provenientes da leitura do GPS. Essa premissa é baseada no fato de
que o compilador do programa informa que a utilização da memória SRAM está acima
do limite, sendo que provavelmente isso está acarretando erros.
Essa premissa é reforçada pelo fato de um programa que capta os dados de apenas
um sensor e os dados do GPS ter sido criado e se mostrado funcional. Esse programa,
apesar de utilizar grande quantidade de memória SRAM ainda estava dentro de seu limite,
com isso o programa conseguiu rodar e ser validado.
Sendo o problema da memória SRAM, é possível que, ao se utilizar uma placa
Arduíno com uma maior capacidade de memória (como a Arduíno MEGA), o programa
rode com múltiplos sensores sem problema.
- 50 -
Capítulo 4 – Montagens, Testes, Validações e
Calibrações
4.1 Introdução
Os objetivos desse capítulo são:
Descrever o método de montagem de uma placa que foi produzida com a
finalidade de realizar a interconexão dos sensores (sensor de corrente Allegro
ACS758 e sensores Davis de Radiação Solar)19 com o Arduíno;
Realizar testes em bancada com essa placa para validá-la e testes com os sensores
reais utilizando a programação desenvolvida no Capítulo 3;
Levantar as curvas de calibração dos sensores.
O Capítulo 4 começa com a apresentação dos sensores que foram utilizados nesse
trabalho. Em seguida são apresentados o conceito e o desenvolvimento da placa de
interconexão, mostrando suas principais vantagens, o resultado final após sua produção e
o teste de validação da mesma. Concluindo o capítulo são apresentados os testes de
validação do sensor de corrente e do sensor piranômetro bem como o levantamento de
suas curvas de calibração.
4.2 Sensores Reais
Com os programas prontos, foram então substituídos dois dos potenciômetros por
sensores reais que poderão ser utilizados no barco. Os sensores utilizados foram um de
corrente e um piranômetro.
19 Esses sensores serão detalhados no subcapítulo 4.2
- 51 -
4.2.1 Sensor de Corrente ACS758ECB-200B
A família de sensores de corrente Allegro ACS758 pode ser usada tanto para
medição de correntes contínuas como alternadas. Esses sensores consistem de um circuito
de efeito HALL linear de baixa saída com um caminho condutor de cobre perto do bloco
de material semicondutor. Aplicada uma corrente que flui por este caminho condutor de
cobre, é gerado um campo magnético que o circuito integrado de efeito HALL converte
em uma tensão proporcional. A precisão do dispositivo é otimizada devido à proximidade
do sinal magnético e do transdutor HALL. Devido a espessura do condutor de cobre, o
aparelho consegue aguentar altas condições de sobrecorrente, sendo sua resistência típica
de 100 µΩ gerando assim poucas perdas [8].
Suas principais vantagens são [8]:
Tempo de 3 µs de resposta ao degrau de corrente de entrada;
Histerese magnética quase zero;
Tensão de saída proporcional às correntes AC e DC;
Não contém chumbo; e
São todos calibrados antes do envio;
O ACS758 tem como saída um sinal analógico, Vout, que varia linearmente com
uma corrente uni- ou bidirecional DC ou AC. A utilização de um capacitor de
acoplamento entre a saída e o pino terra, Cf na faixa de 0,1 µF, como pode ser visto na
Figura 30, ajuda a eliminar interferências [8].
- 52 -
Figura 30– Esquemático do ACS758 [8]
Pode-se ver na Figura 31 o diagrama de pinagem do sensor de corrente.
Figura 31– Diagrama de Pinagem [8]
O sensor da família ACS758 utilizado foi o ACS758ECB-200B-PFF como pode-
se ver na Figura 32.
- 53 -
Figura 32– ACS758 PFF [8]
A inscrição 200B presente no sensor indica que o sensor tem uma sensibilidade
de corrente que vai de -200A a +200A. Segue a Tabela 7 com as informações principais
do sensor utilizado [8].
Tabela 7- Dados do sensor de corrente ACS758ECB-200B
4.2.2 Sensor Piranômetro Vantage Pro
Os sensores Davis de Radiação Solar são instrumentos de precisão que detectam
a radiação com comprimentos de onda na faixa de 300 a 1100 nanômetros. O Sensor de
Radiação Solar, ou piranômetro solar, mede a radiação global, que é a soma no ponto de
medição tanto da radiação direta quanto da difusa. O transdutor do sensor, que converte
a radiação incidente em corrente elétrica, é um fotodiodo de silício com grande resposta
Característica Mínimo Típico Máximo Unidade
Corrente Primária -200 - 200 A
Sensibilidade - 10 - mV/A
Ruído - 3 - mV
- 54 -
espectral. Utilizando a tensão de saída do sensor pode-se calcular facilmente o valor da
radiação solar. O transdutor é hermeticamente selado garantindo uma maior segurança na
água. O sensor ainda é composto por um corpo externo que protege o sensor de radiação
térmica e fornece um caminho de ar para o resfriamento do corpo do piranômetro [7].
As principais informações sobre o piranômetro podem ser encontradas na Tabela
8 [7].
Tabela 8– Características do Piranômetro
Pode-se ainda observar nas Figuras 33 e 34 o corpo interno e externo deste
piranômetro.
Geral Característica
Temperatura Operação -40C a +65C
Temperatura de Armazenamento -45C a +70C
Transdutor Fotodiodo de Silício
Resposta Espectral 300 a 1100 nanômetros
Tamanho do Cabo 0,6 m
Conector RJ-11 Modular
Fio Verde Saída (1,67 mV por W/m²)
Fios Preto e Vermelho Terra
Fio Amarelo Alimentação (3 VDC)
Peso 226 g
- 55 -
Figura 33– Corpo interno do Piranômetro
Figura 34– Corpo Externo do Piranômetro
É ainda apresentado na Figura 35 um esquemático dos fios presentes nesse
piranômetro.
- 56 -
Figura 35– Esquemático do Piranômetro [7]
4.3 Placa de Interconexão
Com o objetivo de diminuir o risco de falha de comunicação, foi produzida uma
placa que tem como objetivo fazer uma conexão fixa entre sensores e Arduíno, garantindo
assim uma boa fixação mecânica e conexão elétrica.
Decidiu-se então montar a placa de modo que a mesma se comportasse como um
Shield de Arduíno (plug-and-play), sendo que somente seria necessário empilhar a placa
com o Arduíno e seu Shield GPS já encaixado para que a mesma funcionasse.
Foram utilizados os sensores de corrente e piranômetro (descritos no capítulo 3)
disponíveis no laboratório para montar a placa sendo o sensor de corrente soldado na
placa junto com o conector RJ-11 do sensor piranômetro.
A placa é composta de uma placa padrão para montagem de circuitos, onde foram
soldados os conectores, um sensor de corrente ACS758 ECB-200B, um conector RJ-11
para conexão do piranômetro, 2 LEDs, conectores barra de pinos para a ligação com o
Arduíno e conectores PCB macho para que outros dispositivos possam ser ligados na
placa caso necessário.
- 57 -
O processo de confecção da placa levou em conta a disposição e quantidade dos
pinos presentes na placa Arduíno UNO de modo que fosse possível a conexão através do
empilhamento, garantindo assim firmeza mecânica.
Em um primeiro momento foi confeccionada uma placa, que pode ser vista na
Figura 36, que só acessava uma parte dos pinos do Arduíno, sendo esses os pinos
necessários para a conexão dos sensores. A placa produzida se mostrou funcional, sendo
capaz de captar os dados dos sensores e, através do programa, armazená-los no SD.
Figura 36– Primeira Placa Produzida
A placa funcionou durante os testes iniciais, porém apresentou um grande
problema, sendo este a falta da sustentação mecânica, uma vez que a conexão era feita
apenas através dos pinos de um dos lados do Arduíno UNO como pode ser visto na Figura
37. Como esse problema tirava uma das funcionalidades da placa (fixação mecânica), foi
necessária a produção de outra que acessasse todos os pinos e garantisse a sustentação.
- 58 -
Figura 37– Problema de Sustentação Apresentado pela Placa
Com o objetivo de acabar com o problema de sustentação apresentado pela placa
anterior, foi montada a placa final apresentada na Figura 38. A mesma, além de se
conectar em todos os pinos do Arduíno, como pode ser visto na Figura 39, e assim dar
sustentação, também apresenta saída na parte superior da placa permitindo assim a
conexão de mais objetos a esta placa caso necessário. Essa nova placa possui ainda um
LED vermelho que indica se há algum mau contato do SD ou se o mesmo não foi
identificado pelo programa. O LED verde mostra que a configuração 20 do ponto de
corrente zero foi realizada corretamente.
20 Será comentado na seção 4.5.1.
- 59 -
Figura 38– Vista Superior da Placa de Interconexão Final
Figura 39– Placa Empilhada com o Problema de Sustentação Resolvido
- 60 -
4.3.1 Teste preliminar da Placa
Uma vez que a placa de interconexão estava pronta, foi preciso testá-la e garantir
que as soldagens estavam feitas corretamente e que todos os contatos funcionavam
perfeitamente. Para isso foi utilizado o programa de captação de dados dos sensores e
armazenamento no SD e foram utilizados os sensores piranômetro e de corrente.
Foi curto circuitada uma fonte de corrente com o sensor ACS758 onde foi variada
a corrente (0 a 2A), além disso foi ligada uma fonte de luz externa que era aproximada e
afastada do sensor piranômetro. Depois foi observado se os dados obtidos foram
armazenados corretamente no cartão micro-SD.
Uma vez que tudo foi analisado, pode-se afirmar que a placa de interconexão
funciona corretamente.
Nas Figuras 40 e 41 pode-se observar como foi feito o experimento de teste da
placa.
Figura 40– Piranômetro e Fonte conectados à Placa
- 61 -
Figura 41– Todas as Conexões Feitas para o Teste
4.4 Ideia de Aplicação das Placas
Essas placas de interconexão são uma das possíveis configurações de conexão
entre os sensores e o Arduíno, sendo até o momento a melhor opção encontrada (se
comparada com a opção de se deixar os sensores dispostos em lugares distintos do barco,
dificultando seu acesso). Além de permitirem uma conexão firme e segura, ainda são de
fácil produção, remoção e alteração (reparo) caso futuramente algum dos sensores
apresente defeito.
Uma opção de configuração seria produzir uma placa parecida com a mostrada na
Figura 38, porém ao invés de saída do tipo macho acima da placa, continuar utilizando
saídas do tipo fêmea iguais às apresentadas pelo Arduíno, de modo a permitir o
empilhamento de outra placa no sistema. Assim será possível produzir uma placa com os
sensores de corrente e tensão que se conectarão aos painéis solares, além do piranômetro,
e outra placa com o sensor de corrente que será conectado ao motor e o sensor de tensão
conectado às baterias.
- 62 -
Essa disposição permite um maior empilhamento de placas, além de separar os
sensores dos sistemas. Assim, caso exista algum problema em um dos sensores, pode-se
resolver isso na placa específica.
4.5 Curvas de Calibração
Uma vez a placa de interconexão pronta, foram testados os sensores para que fosse
possível observar se tudo estava ocorrendo dentro da normalidade e para saber se os dados
lidos eram consistentes.
4.5.1 Curva de Calibração do Sensor de Corrente
Para que o Arduíno possa converter o valor de tensão fornecido pela saída do
sensor de corrente em uma corrente real lida pelo mesmo sensor, ele precisa de um ponto
de calibração. Isso ocorre pois o sensor de corrente pode medir uma variação de -200A a
+200A. Como o Arduíno transforma uma entrada analógica em um ponto entre 0 e 1023,
o ponto de corrente zero não equivale ao ponto zero da entrada analógica. Por isso, o
primeiro passo é descobrir qual o valor do ponto da entrada analógica equivalente a
corrente zero amperes. Isso é feito com uma linha de código inserida no programa, de
modo que toda vez que o mesmo é iniciado o programa captura o valor de corrente zero
e passa a utilizá-lo nos seus cálculos. Com isso é importante que a corrente passando pelo
sensor seja zero quando se ligar o Arduíno.
Uma vez a calibração do sensor feita no Arduíno, foi iniciada a aquisição de dados
para o levantamento da curva de calibração. Com o auxílio de uma fonte presente no
laboratório que foi utilizada como fonte de corrente (Magna Power XR Serie) foi ligado
o sensor de corrente em curto com a fonte. Com a calibração do ponto zero feita, foi ligada
a fonte de corrente e foram então comparados os valores apresentados pela fonte e lidos
pelo programa do Arduíno.
- 63 -
Como a sensibilidade do Arduíno é maior do que a variação que o sensor de
corrente apresenta (um ponto para o Arduíno é em média 4,88mV, enquanto 1 ampére
para o sensor de corrente é de 10mV) os valores lidos estão muito próximos dos reais
como pode ser visto na Tabela 9.
Tabela 9– Valores para Calibração
Os valores foram então colocados no MatLab para gerar o gráfico de calibração
apresentado na Figura 42:
Corrente pela Fonte Corrente pelo Arduíno Erro (%)
1 0,98 2,00%
2 1,98 1,00%
3 2,93 2,33%
4 3,91 2,25%
5 4,89 2,20%
6 5,87 2,17%
7 6,84 2,29%
8 7,82 2,25%
9 8,8 2,22%
10 9,77 2,27%
- 64 -
Figura 42– Curva de Calibração do Sensor de Corrente
Como se pode observar pela curva da Figura 42 e Tabela 9, os valores lidos pelo
Arduíno são quase iguais aos valores reais. Com isso, a utilização deste gráfico só será
necessária caso seja preciso uma alta acurácia.
Na Figura 43 pode-se ver como foi feita a experiência para o levantamento de
dados da curva de calibração.
- 65 -
Figura 43– Experimento para Levantamento da Curva de Calibração
4.5.2 Curva de Calibração do Piranômetro
Depois de feito o levantamento da curva de calibração para o sensor de corrente,
foi então montado um experimento para o levantamento da curva de calibração do
piranômetro.
Esta curva de calibração é importante, pois os valores lidos pelo Arduíno
apresentam discrepâncias consideráveis em relação aos valores reais lidos pelo
- 66 -
piranômetro. Isso ocorre pois o piranômetro tem entrada de 3V e pode mostrar valores de
até 1800 W/m² com uma variação de 1 W/m². Com isso é possível calcular que cada valor
variado pelo piranômetro equivale a um acréscimo ou decréscimo de tensão de 1,67mV
na saída do mesmo. Logo o valor de leitura de 1 W/m² seria igual a uma saída de 1,67mV.
O problema é que o Arduíno não tem essa sensibilidade, sendo que na média a
variação de 1 ponto para ele equivale a 4,88mV. O que ocorre é que para o primeiro ponto
lido pelo Arduíno a tensão apresentada deve ser de no mínimo 10mV, sendo qualquer
tensão abaixo dessa lida como o ponto zero. Assim, enquanto o piranômetro já variou
quase 8 W/m², o Arduíno terá uma leitura de 1W/m². A leitura do Arduíno fica então bem
defasada em relação a leitura do piranômetro.
Este erro é posteriormente diluído pelo Arduíno, sendo que para pontos médios
entre 0 e 1800 W/m², os valores lidos pelo Arduíno se aproximam muito dos valores reais
lidos pelo piranômetro.
Outro problema volta a ocorrer para valores mais altos de radiação onde, devido
a diluição do erro feito pelo Arduíno, os valores lidos pelo programa tornam-se superiores
aos valores reais apresentados pelo piranômetro.
Para ser possível uma análise de dados mais precisa, essa experiência foi feita com
um total de 20 pontos de comparação, onde além de serem anotadas as leituras feitas pelo
piranômetro e pelo arduíno, ainda foram verificados o valor do ponto lido pelo Arduíno
e a tensão medida na saída do piranômetro.
A experiência foi feita utilizando-se uma fonte de luz artificial que era colocada a
uma distância fixa do piranômetro. Então um voltímetro era colocado entre o Vout do
piranômetro e seu GND. A tensão era observada e anotada, sendo que o cálculo do valor
lido pelo piranômetro era feito da seguinte forma:
𝑅𝑎𝑑𝑖𝑎çã𝑜 =𝑉𝑜𝑢𝑡
1,67 W/m²
- 67 -
Depois foi então observado o valor lido pelo Arduíno e a qual ponto (entre 0 e
1023) este valor correspondia. Este procedimento foi feito para um total de 20 pontos e
pode ser visto na Tabela 10.
Tabela 10– Valores para Calibração do sensor Piranômetro
Uma vez de posse da Tabela 10 foi possível a montagem de dois gráficos
comparativos. No primeiro, Figura 44, são plotadas juntas as curvas da leitura da radiação
feita pelo piranômetro e a leitura feita pelo Arduíno em relação ao total de pontos
adquiridos. O objetivo desse gráfico é mostrar o quão próximas são essas curvas. No
segundo, Figura 45, é plotado a radiação do piranômetro em relação a radiação do
Arduíno, onde é possível perceber que as radiações captadas pelo Arduíno e pelo
piranômetro se relacionam muito próxima a uma reta.
Número de Dados
Tensão medida Pira (mV)
Ponto medido Arduíno
Radiação Pira (W/m2)
Radiação Arduíno (W/m2) Erro (%)
1 6,9 0 4,132 0
2 14,3 1 8,563 2,93 -192,25%
3 17,7 2 10,599 5,87 -80,56%
4 23 3 13,772 8,8 -56,51%
5 47,7 9 28,563 26,39 -8,23%
6 62,6 12 37,485 35,19 -6,52%
7 104,5 22 62,575 64,52 3,01%
8 160 34 95,808 99,71 3,91%
9 200 44 119,760 129,03 7,18%
10 248 55 148,503 161,29 7,93%
11 327 73 195,808 214,08 8,53%
12 481 108 288,024 316,76 9,07%
13 561 126 335,928 369,5 9,09%
14 684 154 409,581 451,61 9,31%
15 1301 299 779,042 876,83 11,15%
16 1460 336 874,251 985,34 11,27%
17 2020 465 1209,581 1363,64 11,30%
18 2120 491 1269,461 1439,89 11,84%
19 2470 570 1479,042 1671,56 11,52%
20 3300 760 1976,048 2228,74 11,34%
- 68 -
Figura 44– Comparação entre as Curvas
Figura 45– Comparação entre os Dados do Arduíno e do Piranômetro
- 69 -
Na Figura 46 pode ser vista a bancada com o experimento para o levantamento
de dados para a curva de calibração em andamento.
Figura 46– Experimento para Levantamento da Curva de Calibração do Piranômetro
- 70 -
Capitulo 5 –Resultados.
5.1 Principais Resultados
Os programas foram testados e validados junto com os sensores que, além de
validados, tiveram suas curvas de calibração levantadas.
Na Figura 47 pode-se observar como se apresentam os dados gravados no SD,
sendo seu formato final o de um arquivo .txt.
Figura 47-Arquivo .txt de corrente
O arquivo com as informações salvas do piranômetro também se apresenta de
maneira semelhante como pode-se observar na Figura 48.
- 71 -
Figura 48-Arquivo .txt de radiação
Dos sensores, o único arquivo que se apresenta salvo de maneira diferente é o
arquivo referente os dados do GPS Shield. Na Figura 49 pode-se observar que todas as
informações referentes a uma leitura do GPS Shield ficam agrupadas, facilitando a
identificação do que for lido.
- 72 -
Figura 49-Arquivo .txt do GPS
Nesse ponto é importante ressaltar que apesar do programa que realiza a leitura
simultânea dos dados do Shield GPS e dos outros sensores e ainda salva esses dados no
micro-SD ter sido criado, não foi possível ser feita a validação do mesmo. Isto ocorreu
devido ao fato do Arduíno disponível no laboratório ser o Arduíno UNO, que como já foi
explicado é o mais básico atualmente da família Arduíno. O problema apresentado pelo
UNO refere-se à falta de memória SRAM suficiente, sendo que este problema pode ser
resolvido adquirindo-se uma outra placa da família Arduíno mais robusta, porém mais
cara (aconselhável a utilização da Arduíno MEGA, que pode ser observado na Figura 50,
que possui 8Kb de memória SRAM, 4 vezes mais que a Arduíno UNO).
- 73 -
Figura 50-Arduíno MEGA
Fonte: www.arduino.cc/en/Main/arduinoBoardMega2560
5.2 Ampliações
Os resultados apresentados pelo projeto se mostraram satisfatórios dentro dos
testes realizados e das validações feitas, sendo que surgiu a possibilidade, de em um
projeto futuro, ser uma ampliação desse projeto de modo que o mesmo seja capaz de
realizar a telemetria dos dados em tempo real tanto para o piloto como para a equipe em
terra.
Essa ampliação possibilitará o acompanhamento em tempo real por parte do piloto
e da equipe em terra dos dados que estão sendo armazenados no SD (provenientes dos
sensores) garantindo uma tomada de decisões mais correta.
Os outros pontos que poderão compor tal sistema de telemetria são apresentados
no subcapítulo de trabalhos futuros.
- 74 -
Capítulo 6 – Conclusão
6.1 Objetivos Alcançados
Como foi discutido inicialmente, o objetivo do projeto é propor um sistema de
captação e armazenamento de dados de sensores instalados no barco solar, permitindo a
análise destes dados posteriormente à corrida.
Este objetivo foi parcialmente alcançado já que o protótipo de bancada foi
montado e os principais componentes do sistema testados, sendo os programas
desenvolvidos e os principais sensores a serem utilizados testados e validados. Ainda
assim, o sistema não está pronto, pois faltam alguns componentes e testes até ser confiável
o suficiente para ser aplicado no barco.
Os resultados no entanto foram bem satisfatórios, pois com todos os dados
produzidos é possível solucionar os problemas que apareceram sem muitas dificuldades.
Os principais programas a serem usados foram validados e testados com sensores reais
que podem ser utilizados no barco, a placa de interconexão (até o momento a melhor
solução encontrada) se mostrou eficiente e de firme conexão. Os sensores de corrente e
piranômetro supriram as necessidades dos testes e se mostram aptos a serem
implementados no barco (o sensor de corrente a ser utilizado pode ser da mesma família
do Allegro usado porém com uma amplitude de corrente menor já que o utilizado nos
testes foi para a medição de até 200 A e o máximo exigido no barco é de 90 A). Os
sensores tiveram ainda suas curvas de calibração levantadas de modo que os dados
captados por eles poderão, após pequena análise, ser os mais corretos possíveis.
- 75 -
6.2 Temas para Futuros Projetos
Como tema para futuros projetos, primeiramente seria a utilização de uma placa
mais robusta no sistema e a utilização de um Shield Bluetooth funcional, fazendo as
alterações necessárias nos programas caso sejam necessárias e observando se o programa
final produzido roda corretamente sob essas novas condições.
Outro projeto que deve ser desenvolvido é a produção de um sistema que realize
a telemetria e tratamento dos dados em tempo real no Tablet, como previamente descrito
no subcapítulo 5.2. Esse projeto deverá compreender um dispositivo móvel para interface
com o usuário, uma interface do piloto e uma interface do técnico, como pode ser visto
nos subcapítulos que se seguem.
Este projeto seria o complemento deste aqui apresentado, terminando então como
a parte de armazenamento e telemetria do barco solar.
E por último, seria o programa completo que uniria a telemetria e o
armazenamento e análise de dados para auxiliar a navegação do barco. Esse sistema de
assistência à navegação utilizaria informações sobre o percurso, os dados do GPS, as
medições de consumo, geração, energia solar incidente, estado de carga das baterias, entre
outras para aconselhar o piloto a acelerar ou reduzir a velocidade.
6.2.1 Dispositivo Móvel para Interface com o Usuário
Será o dispositivo que ficará em mão do piloto e possibilitará que o mesmo
observe as informações vindas dos sensores e analisadas por programas apropriados.
O dispositivo móvel consiste de um Tablet que deverá ser montado em um espaço
propício no cockpit do barco para que o piloto ou o técnico possam observar os dados
com facilidade, enquanto pilotam o mesmo.
- 76 -
O ponto principal do dispositivo móvel é um programa que deverá ser
desenvolvido preferencialmente na plataforma JAVA 21 - já que o mesmo possui
portabilidade, assim o mesmo código Java roda em diversas plataformas sem precisar de
alterações. Com isso, as aplicações podem ser facilmente migradas entre servidores– os
quais receberão os dados enviados pelo Arduíno e montarão gráficos em tempo real do
consumo, geração e armazenamento de cada uma das partes a serem analisadas (motor,
baterias, painéis e piranômetro).
Como um exemplo de Tablet para ser utilizado como dispositivo móvel tem-se o
Aakash22.
O Aakash, também conhecido como UbiSlate, é um Tablet de baixo custo baseado
no sistema operacional Android que foi uma iniciativa do governo Indiano para garantir
o acesso e melhorar o programa de estudos de universidades e colégios do país. Ele é
produzido pela companhia Britânica-Canadense DataWind.
Seu projeto original foi chamado de “$35 Laptop” ou Laptop de 35 dólares, sendo
a versão comercial UbiSlate 7 + sendo atualmente comercializada por 60 dólares.
A grande vantagem desse Tablet é que ele atende a todas as necessidades para esse
projeto e sendo de baixo custo, ele contribui para que os gastos com o barco se concentrem
em outros aspectos.
O Tablet da linha Aakash que pode ser utilizado nesse projeto é o UbiSlate 7 Cz
que custa 6000 rúpias, ou 220 reais (como pode ser observado na Figura 51). Ele possui
conexão bluetooth, tem Wifi, possui pacote Office e capacidade para um Micro Sd de 5
GB. Seu sistema operacional é o Android 4.2.2 e possui ainda uma memória RAM de 1
GB podendo ser expandida até 32 GB [2].
21 Outras vantagens da plataforma Java incluem que a tecnologia e ambientes de programação são grátis e que é uma linguagem orientada a objetos, tornando-a bem poderosa. 22 www.akashtablet.com
- 77 -
Baseando-se nas especificações acima pode-se ver que o custo-benefício é muito
bom, já que a maioria dos Tablets atualmente com as mesmas especificações custam em
torno de 500 reais
Figura 51- Tablet Aakash, UbiSlate 7Cz [2]
É importante salientar que o programa a ser executado no Tablet deverá ter pelo
menos 2 interfaces diferentes, uma para o piloto e uma para o técnico.
6.2.1.1 Interface do Piloto
A interface voltada para o piloto consistirá de uma tela mais simplificada, voltada
para dados considerados importantes durante a prova. Esses dados serão velocidade de
deslocamento, direção de deslocamento, nível de carga da bateria e se a geração de
energia está maior ou menor que o consumo.
Caso durante a prova, o consumo seja maior que a geração, o display do programa
irá mostrar essa informação em destaque, ressaltando também o nível de carga da bateria.
Se essa situação se prolongar e o nível de carga da bateria ficar abaixo de determinado
limite (a ser definido pela equipe), um sinal sonoro soará para alertar o piloto da
eminência de falta de carga da bateria e possível comprometimento do deslocamento do
- 78 -
barco. Será ideal e possível também, futuramente, o envio de tal informação em tempo
real para a equipe em terra, de modo que a mesma possa analisar a situação e ajudar nas
decisões do piloto.
A ideia de reduzir o número de dados mostrados ao piloto e a interface simples e
sem muitos botões é para facilitar o envio de informações essenciais ao piloto, facilitando
a identificação dessas por ele durante a prova.
Tem-se na Figura 52 um exemplo de como pode ser formada essa interface do
piloto.
Figura 52-Interface Piloto
6.2.1.2 Interface do Técnico
Essa será uma interface mais completa. Além de todos os dados que a interface do
piloto terá, ela ainda possuirá display de gráficos dos sensores em tempo real, a
- 79 -
possibilidade de sobrepor os gráficos, botões que possibilitem achar imediatamente o
ponto de máximo consumo e máxima produção de energia, entre outros.
Esse display também deverá informar em tempo real a situação da bateria e a
relação consumo x geração.
Outra funcionalidade será a relação entre geração fotovoltaica e radiação medida
pelo piranômetro. Essa relação visa mostrar se, apesar das perdas, a produção de energia
está sendo satisfatória em relação ao nível da radiação solar.
A parte do display com a direção de deslocamento também poderá ser fechada
caso o técnico deseje, já que essa informação não é tão útil para ele.
Poderá ser incluído ainda um gráfico de eficiência do motor, mostrando a energia
fornecida a ele e a velocidade do barco.
Tem-se na Figura 53 um exemplo de como pode ser formada a interface do
técnico.
Figura 53- Interface Técnico
- 80 -
Referências Bibliográficas
[1] Rafael de O. Rodrigues, “Catamarã Mangue”, Rio de Janeiro, RJ, Brasil, 26
de Fevereiro de 2014, Relatório As Built do catamarã Mangue.
[2] Site Oficial Aakash, “UbiSlate 7CZ”. Disponível em:
http://www.akashtablet.com/product.php?prodid=12. Acessado em
15/05/2014
[3] Renato Aloi, “Curso Arduíno”. Disponível em:
http://renatoaloi.blogspot.com.br/. Acessado em 15/05/2014
[4] Anonio Diego Santos Abreu, “ Arduíno-Plataforma Eletrônica
Microcontroladora”, São Luís, MA, Brasil, 2012.
[5] Michael McRoberts, “Arduíno Básico”, São Paulo, SP, Brasil, 2011.
[6] Fórum oficial Arduíno, “Arduíno GPS Shield by iteadstudio.com”. Disponível
em:
http://forum.arduino.cc/index.php?PHPSESSID=neu8cn2ofecavdnjuau57aron
5&topic=113603.0. Acessado em 15/04/2014
[7] Davis Instruments, “Solar Radiation Sensor 6450”. Disponível em
http://www.davisnet.com/product_documents/weather/spec_sheets/6450_SS.
pdf. Acessado em 15/05/2014
[8] Allegro MicroSystems, “Thermally Enhanced, Fully Integrated, Hall Effect-
Based Linear Current Sensor IC with 100 μΩ Current Conductor”.
Disponível em http://www.allegromicro.com/en/Products/Current-Sensor-
ICs/Fifty-To-Two-Hundred-Amp-Integrated-Conductor-Sensor-
ICs/ACS758.aspx. Acessado em 15/05/2014.
[9] ITEAD Studio, “ITEAD GPS SHIELD”. Disponível em:
http://imall.iteadstudio.com/im120417017.html. Acessado em 15/05/2014.
[10]
[11]
Wikipédia Brasil, “Efeito Fotovoltaico”. Disponível em:
http://pt.wikipedia.org/wiki/Efeito_fotovoltaico. Acessado em 15/05/2014.
Site Oficial Arduíno, “Introduction”. Disponível em
http://arduino.cc/en/Guide/Introduction. Acessado em 15/05/2014
- 81 -
[12]
[13]
[14]
[15]
ITEAD Studio Forum, “GPS Speed”. Disponível em:
http://forum.iteadstudio.com/viewtopic.php?f=25&t=759. Acessado em
15/05/2014
Mikal Hart, “An extensive example of many interesting TinyGPS++
features”. Disponível em: https://tiny-circuits.com/learn/using-gps-
tinyshield/. Acessado em 15/05/2014
Grupo de Trabalho de Energia Solar-GTES, “Manual de Engenharia para
Sistemas Fotovoltaicos”, Rio de Janeiro, RJ, Brasil, Agosto de 2004
Xia, Chang Liang Ph.D., “Permanent Magnet Brushless DC Motor Drives
And Controls”, Singapura, Singapura, Junho de 2012.
- 82 -
Anexo I
Programa Base [3].
#include <EEPROM.h> //chama a biblioteca EEPROM
#include <SD.h> // chama a biblioteca SD
File arquivo; // classe da biblioteca SD que ajuda na manipulação de arquivos
int sd=4; // pino onde o SD está conectado, para o ethernet Shield o padrão é o pino 4;
para o GPS ITEAD é o 10
byte inicio_ok;
void setup()
inicio_ok=1;
Serial.begin(9600);
if(!SD.begin(sd)) //verificar se o SD inicializou certo
Serial.println("Erro ao iniciar cartão SD");
inicio_ok=0;
return;
Serial.println("Iniciacao OK!");
void loop()
if (inicio_ok) // se erro ao iniciar o SD, o inicio_ok será zero o não executará o loop
int opcao = Serial.read(); // o objetivo é configurar o tempo entre a leitura do sensor e
o envio para a tela
if (opcao == 'c') // configurar um tempo para leitura do sensor
Serial.println("opcao Configuracao Selecionada");
opcao = Serial.read();
while(opcao == -1) // se não colocarmos nada em opção ele vai ficar preso nesse
loop esperando você configurar o tempo que quer
opcao = Serial.read();
int valorConfig = opcao - 48; // isso que o valor que ele volta é da tabela ASCII
EEPROM.write(0, valorConfig); // vamos configurar a EEPROM AGORA, vamos
gravar na posição 0
Serial.print("Valor gravado com sucesso ");
Serial.println(valorConfig);
else if(opcao == 'w')
while(opcao != 'x') // Vai ficar lendo o sensor e salvando até que aperte o x para sair
- 83 -
int leiturasensor = analogRead(A0);
float tensao = leiturasensor*5.000/1023.000;
arquivo = SD.open("tensao.txt", FILE_WRITE);
if(arquivo)
arquivo.print("Valor do sensor de tensao em ");
arquivo.print(millis());
arquivo.print(" ms ");
arquivo.println(tensao);
arquivo.close();
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura do sensor em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
else
Serial.println("Erro ao abrir aqruivo para escrita"); // caso não consiga abrir para
salvar
opcao = Serial.read(); // pois se quisermos sair ele tem que ler opção em algum
momento
Serial.println("Terminando Leitura do sensor de tensao");
else if(opcao =='r') // mostra o que foi salvo no arquivo txt do SD
arquivo= SD.open("tensao.txt");
if(arquivo)
while(arquivo.available())
Serial.write(arquivo.read());
arquivo.close();
Serial.println("termino do arquivo");
else
Serial.println("erro ao abrir arquivo para leitura");
else if (opcao == 'e') // apagar o arquivo sensor.txt
SD.remove("tensao.txt");
if(!SD.exists("tensao.txt"))
Serial.println("Arquivo apagado com sucesso");
else
Serial.println("Erro ao apagar");
- 84 -
- 85 -
Anexo II
Programa Completo.
#include <EEPROM.h> //chama a biblioteca EEPROM
#include <SD.h> // chama a biblioteca SD
File arquivo; // classe da biblioteca SD que ajuda na manipulação de arquivos
File arquivo2;
File arquivo3;
int sd=10; // pino onde o SD está conectado, para o ethernet Shield o padrão é o pino
4; para o GPS ITEAD é o 10
byte inicio_ok;
int calibracao=0;
int led1=9;
int led2= 8;
void setup()
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
calibracao=analogRead(A0); // calibração do sensor de corrente sem corrente
if (calibracao) // verificar se calibrou corretamente
digitalWrite(led1, HIGH);
inicio_ok=1;
Serial.begin(115200);
if(!SD.begin(sd)) //verificar se o SD inicializou certo
Serial.println("Erro ao iniciar cartão SD");
digitalWrite(led2, HIGH);
inicio_ok=0;
return;
Serial.println("Iniciacao OK!");
void loop()
if (inicio_ok) // se erro ao iniciar o SD, o inicio_ok será zero o não executará o loop
int opcao = Serial.read(); // o objetivo é configurar o tempo entre a leitura do sensor e
o envio para a tela
if (opcao == 'c') // configurar um tempo para leitura do sensor
Serial.println("opcao Configuracao Selecionada");
- 86 -
opcao = Serial.read();
while(opcao == -1) // se não colocarmos nada em opção ele vai ficar preso nesse
loop esperando vc configurar o tempo que quer
opcao = Serial.read();
int valorConfig = opcao - 48; // isso que o valor que ele volta é da tabela ASCII
EEPROM.write(0, valorConfig); // vamos configurar a EEPROM AGORA, vamos
gravar na posição 0
Serial.print("Valor gravado com sucesso ");
Serial.println(valorConfig);
else if(opcao == 'w')
while(opcao != 'x') // Vai ficar lendo o sensor e salvando até que aperte o x para
sair
int leiturasensor = analogRead(A0);
float corrente = (leiturasensor-calibracao)*5.000/1023.000/0.010;
// Serial.println(corrente);
arquivo = SD.open("corrente.txt", FILE_WRITE);
if(arquivo)
arquivo.print("Valor da corrente em ");
arquivo.print(millis());
arquivo.print(" ms ");
arquivo.print(corrente);
arquivo.println(" A");
arquivo.close();
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura da corrente em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
Serial.print("Corrente = ");
Serial.print(corrente);
Serial.println(“ A”);
int leiturasensor1 = analogRead(A1);
float pira = leiturasensor1*1.667*1800.000/1023.000;
//Serial.println(leiturasensor1);
arquivo2 = SD.open("radi.txt", FILE_WRITE);
if(arquivo2)
arquivo2.print("Valor da radiacao em ");
arquivo2.print(millis());
arquivo2.print(" ms ");
arquivo2.print(pira);
arquivo2.println(" W/m²");
arquivo2.close();
- 87 -
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura da radiacao em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
Serial.print("Radiacao = ");
Serial.print(pira);
Serial.println(" W/m²");
int leiturasensor2 = analogRead(A2);
float tensao2 = leiturasensor2*5.000/1023.000;
// Serial.println(tensao1);
int poten= tensao2*1.000*corrente;
arquivo3 = SD.open("poten.txt", FILE_WRITE);
if(arquivo3)
arquivo3.print("Valor da potencia em ");
arquivo3.print(millis());
arquivo3.print(" ms ");
arquivo3.print(poten);
arquivo3.println(" W");
arquivo3.close();
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura da potencia em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
Serial.print("Potencia = ");
Serial.print(poten);
Serial.println(" W");
else
Serial.println("Erro ao abrir arquivo para escrita"); // caso não consiga abrir para
salvar
opcao = Serial.read(); // pois se quisermos sair ele tem que ler opção em algum
momento
Serial.println("Terminando Leitura dos sensores");
else if(opcao =='r') // mostra o que foi salvo no arquivo txt do SD
arquivo= SD.open("corrente.txt");
if(arquivo)
while(arquivo.available())
Serial.write(arquivo.read());
arquivo.close();
- 88 -
Serial.println("termino do arquivo 1");
arquivo2= SD.open("radi.txt");
if(arquivo2)
while(arquivo2.available())
Serial.write(arquivo2.read());
arquivo2.close();
Serial.println("termino do arquivo 2");
arquivo3= SD.open("poten.txt");
if(arquivo3)
while(arquivo3.available())
Serial.write(arquivo3.read());
arquivo3.close();
Serial.println("termino do arquivo 3");
else
Serial.println("erro ao abrir arquivo para leitura");
else if (opcao == 'e') // apagar o arquivo .txt
SD.remove("corrente.txt");
if(!SD.exists("corrente.txt"))
Serial.println("Arquivo 1 apagado com sucesso");
SD.remove("radi.txt");
if(!SD.exists("radi.txt"))
Serial.println("Arquivo 2 apagado com sucesso");
SD.remove("poten.txt");
if(!SD.exists("poten.txt"))
Serial.println("Arquivo 3 apagado com sucesso");
else
Serial.println("Erro ao apagar");
- 89 -
Anexo III
Programa de Leitura e Armazenamento de dados do GPS Shield [13].
#include <EEPROM.h> //chama a biblioteca EEPROM
#include <SD.h> // chama a biblioteca SD
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
File arquivo; // classe da biblioteca SD que ajuda na manipulação de arquivos
int sd=10; // pino onde o SD está conectado, para o ethernet Shield o padrão é o pino
4; para o GPS ITEAD é 10
byte inicio_ok;
static const int RXPin = 2, TXPin = 3;
static const uint32_t GPSBaud = 4800;
TinyGPSPlus gps;
SoftwareSerial ss(RXPin, TXPin);
void setup()
Serial.begin(115200);
ss.begin(38400);
ss.print("$PUBX,41,1,0007,0003,4800,0*13\r\n"); // muda a velocidade do Itead
ss.flush();
delay(50);
ss.begin(4800); // reseta a velocidade do Software serial
ss.flush();
delay(50);
Serial.println(F("Sats HDOP Latitude Longitude Date Time Date Alt
Course Speed "));
Serial.println(F(" (deg) (deg) Age (m) - from GPS -
-"));
Serial.println(F("------------------------------------------------------------------------------------
----------------"));
inicio_ok=1;
if(!SD.begin(sd)) //verificar se o SD inicializou certo
Serial.println("Erro ao iniciar cartão SD");
inicio_ok=0;
return;
- 90 -
Serial.println("Iniciacao OK!");
void loop()
if (inicio_ok) // se erro ao iniciar o SD, o inicio_ok será zero o não executará o loop
int opcao = Serial.read(); // o objetivo é configurar o tempo entre a leitura do sensor e
o envio para a tela
if (opcao == 'c') // configurar um tempo para leitura do sensor
Serial.println("opcao Configuracao Selecionada");
opcao = Serial.read();
while(opcao == -1) // se não colocarmos nada em opção ele vai ficar preso nesse
loop esperando você configurar o tempo que quer
opcao = Serial.read();
int valorConfig = opcao - 48; // isso que o valor que ele volta é da tabela ASCII
EEPROM.write(0, valorConfig); // vamos configurar a EEPROM AGORA, vamos
gravar na posição 0
Serial.print("Valor gravado com sucesso ");
Serial.println(valorConfig);
if(opcao == 'w')
while(opcao != 'x') // Vai ficar lendo o sensor e salvando até que aperte o x para
sair
arquivo = SD.open("gp.txt", FILE_WRITE);
if(arquivo)
arquivo.print("Satélites ");
arquivo.println(gps.satellites.value());
arquivo.print("HDOP ");
arquivo.println(gps.hdop.value());
arquivo.print("Latitude ");
arquivo.println(gps.location.lat());
arquivo.print(" Longitude ");
arquivo.println(gps.location.lng());
arquivo.print("data ");
arquivo.println(gps.date.value());
arquivo.print("hora");
arquivo.println(gps.time.value());
arquivo.print("Altitude ");
- 91 -
arquivo.print(gps.altitude.meters());
arquivo4.println(" metros");
arquivo.print("Velocidade ");
arquivo.print(gps.speed.kmph());
arquivo.println(" Kmph");
arquivo.close();
delay(1000 * EEPROM.read(0));
printInt(gps.satellites.value(), gps.satellites.isValid(), 5);
printInt(gps.hdop.value(), gps.hdop.isValid(), 5);
printFloat(gps.location.lat(), gps.location.isValid(), 11, 6);
printFloat(gps.location.lng(), gps.location.isValid(), 12, 6);
printDateTime(gps.date, gps.time);
printFloat(gps.altitude.meters(), gps.altitude.isValid(), 7, 2);
printFloat(gps.speed.kmph(), gps.speed.isValid(), 6, 2);
Serial.println();
else
Serial.println("Erro ao abrir arquivo para escrita"); // caso não consiga abrir para
salvar
opcao = Serial.read(); // pois se quisermos sair ele tem que ler opção em algum
momento
Serial.println("Terminando Leitura dos sensores");
if(opcao =='r') // mostra o que foi salvo no arquivo txt do SD
arquivo= SD.open("gp.txt");
if(arquivo)
while(arquivo.available())
Serial.write(arquivo.read());
arquivo.close();
Serial.println("termino do arquivo 1");
else
Serial.println("erro ao abrir arquivo para leitura");
else if (opcao == 'e') // apagar o arquivo txt
SD.remove("gp.txt");
if(!SD.exists("gp.txt"))
Serial.println("Arquivo 1 apagado com sucesso");
- 92 -
else
Serial.println("Erro ao apagar");
static void smartDelay(unsigned long ms) // a partir daqui são definidas funções para
facilitar a aquisição de dados do GPS;
unsigned long start = millis();
do
while (ss.available())
gps.encode(ss.read());
while (millis() - start < ms);
static void printFloat(float val, bool valid, int len, int prec)
if (!valid)
while (len-- > 1)
Serial.print('*');
Serial.print(' ');
else
Serial.print(val, prec);
int vi = abs((int)val);
int flen = prec + (val < 0.0 ? 2 : 1); // . and -
flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
for (int i=flen; i<len; ++i)
Serial.print(' ');
smartDelay(0);
static void printInt(unsigned long val, bool valid, int len)
char sz[32] = "*****************";
if (valid)
sprintf(sz, "%ld", val);
- 93 -
sz[len] = 0;
for (int i=strlen(sz); i<len; ++i)
sz[i] = ' ';
if (len > 0)
sz[len-1] = ' ';
Serial.print(sz);
smartDelay(0);
static void printDateTime(TinyGPSDate &d, TinyGPSTime &t)
if (!d.isValid())
Serial.print(F("********** "));
else
char sz[32];
sprintf(sz, "%02d/%02d/%02d ", d.month(), d.day(), d.year());
Serial.print(sz);
if (!t.isValid())
Serial.print(F("******** "));
else
char sz[32];
sprintf(sz, "%02d:%02d:%02d ", t.hour(), t.minute(), t.second());
Serial.print(sz);
printInt(d.age(), d.isValid(), 5);
smartDelay(0);
static void printStr(const char *str, int len)
int slen = strlen(str);
for (int i=0; i<len; ++i)
Serial.print(i<slen ? str[i] : ' ');
smartDelay(0);
- 94 -
Anexo IV
Programa completo dos Sensores mais o GPS que não pôde ser testado.
#include <EEPROM.h> //chama a biblioteca EEPROM
#include <SD.h> // chama a biblioteca SD
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
File arquivo; // classe da biblioteca SD que ajuda na manipulação de arquivos
File arquivo2;
File arquivo3;
File arquivo4;
int sd=10; // pino onde o SD está conectado, para o ethernet shield o padrão é o pino
4; para o GPS ITEAD é o 10
byte inicio_ok;
int calibracao=0;
int led1=9;
int led2= 8;
static const int RXPin = 2, TXPin = 3; // defini os pinos de comnicação
static const uint32_t GPSBaud = 4800; // seta a velocidade do GPS desejada
TinyGPSPlus gps;
SoftwareSerial ss(RXPin, TXPin);
void setup()
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
calibracao=analogRead(A0); // calibração do sensor de corrente sem corrente
if (calibracao)
digitalWrite(led1, HIGH);
Serial.begin(115200);
ss.begin(38400);
ss.print("$PUBX,41,1,0007,0003,4800,0*13\r\n"); // muda a velocidade do Itead
ss.flush();
delay(50);
ss.begin(4800); // reseta a velocidade do Software serial
ss.flush();
delay(50);
- 95 -
Serial.println(F("Sats HDOP Latitude Longitude Date Time Date Alt
Course Speed "));
Serial.println(F(" (deg) (deg) Age (m) - from GPS -
-"));
Serial.println(F("------------------------------------------------------------------------------------
----------------"));
inicio_ok=1;
if(!SD.begin(sd)) //verificar se o SD inicializou certo
Serial.println("Erro ao iniciar cartão SD");
digitalWrite(led2, HIGH);
inicio_ok=0;
return;
Serial.println("Iniciacao OK!");
void loop()
if (inicio_ok) // se erro ao iniciar o SD, o inicio_ok será zero o não executará o loop
int opcao = Serial.read(); // o objetivo é configurar o tempo entre a leitura do sensor e
o envio para a tela
if (opcao == 'c') // configurar um tempo para leitura do sensor
Serial.println("opcao Configuracao Selecionada");
opcao = Serial.read();
while(opcao == -1) // se não colocarmos nada em opção ele vai ficar preso nesse
loop esperando vc configurar o tempo que quer
opcao = Serial.read();
int valorConfig = opcao - 48; // isso que o valor que ele volta é da tabela ASCII
EEPROM.write(0, valorConfig); // vamos configurar a EEPROM AGORA, vamos
gravar na posição 0
Serial.print("Valor gravado com sucesso ");
Serial.println(valorConfig);
else if(opcao == 'w')
while(opcao != 'x') // Vai ficar lendo o sensor e salvando até que aperte o x para
sair
int leiturasensor = analogRead(A0);
float corrente = (leiturasensor-calibracao)*5.000/1023.000/0.010;
// Serial.println(corrente);
- 96 -
arquivo = SD.open("corrente.txt", FILE_WRITE);
if(arquivo)
arquivo.print("Valor da corrente em ");
arquivo.print(millis());
arquivo.print(" ms ");
arquivo.print(corrente);
arquivo.println(" A");
arquivo.close();
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura da corrente em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
Serial.print("Corrente = ");
Serial.print(corrente);
Serial.println(" A");
int leiturasensor1 = analogRead(A1);
float pira = leiturasensor1*1.667*1800.000/1023.000;
//Serial.println(leiturasensor1);
arquivo2 = SD.open("radi.txt", FILE_WRITE);
if(arquivo2)
arquivo2.print("Valor da radiacao em ");
arquivo2.print(millis());
arquivo2.print(" ms ");
arquivo2.print(pira);
arquivo2.println(" W/m²");
arquivo2.close();
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura da radiacao em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
Serial.print("Radiacao = ");
Serial.print(pira);
Serial.println(" W/m²");
int leiturasensor2 = analogRead(A2);
float tensao2 = leiturasensor2*5.000/1023.000;
// Serial.println(tensao1);
int poten= tensao2*1.000*corrente;
arquivo3 = SD.open("poten.txt", FILE_WRITE);
if(arquivo3)
arquivo3.print("Valor da potencia em ");
arquivo3.print(millis());
arquivo3.print(" ms ");
- 97 -
arquivo3.println(poten);
arquivo3.close();
delay(1000 * EEPROM.read(0));
Serial.print("Feita leitura da potencia em ");
Serial.print(EEPROM.read(0), DEC);
Serial.println( " segs ");
Serial.print("Potencia = ");
Serial.println(poten);
arquivo4 = SD.open("gp.txt", FILE_WRITE);
if(arquivo4)
arquivo.print("Satélites ");
arquivo.println(gps.satellites.value());
arquivo.print("HDOP ");
arquivo.println(gps.hdop.value());
arquivo4.print("Latitude ");
arquivo4.println(gps.location.lat());
arquivo4.print(" Longitude ");
arquivo4.println(gps.location.lng());
arquivo4.print("data ");
arquivo4.println(gps.date.value());
arquivo4.print("hora");
arquivo4.println(gps.time.value());
arquivo4.print("Altitude ");
arquivo4.println(gps.altitude.meters());
arquivo4.println(" metros");
arquivo4.print("Velocidade ");
arquivo4.print (gps.speed.kmph());
arquivo4.println(" Kmph");
arquivo4.close();
delay(1000 * EEPROM.read(0));
printInt(gps.satellites.value(), gps.satellites.isValid(), 5);
printInt(gps.hdop.value(), gps.hdop.isValid(), 5);
printFloat(gps.location.lat(), gps.location.isValid(), 11, 6);
printFloat(gps.location.lng(), gps.location.isValid(), 12, 6);
printDateTime(gps.date, gps.time);
printFloat(gps.altitude.meters(), gps.altitude.isValid(), 7, 2);
printFloat(gps.speed.kmph(), gps.speed.isValid(), 6, 2);
Serial.println();
else
Serial.println("Erro ao abrir arquivo para escrita"); // caso não consiga abrir para
salvar
- 98 -
opcao = Serial.read(); // pois se quisermos sair ele tem que ler opção em algum
momento
Serial.println("Terminando Leitura dos sensores");
else if(opcao =='r') // mostra o que foi salvo no arquivo txt do SD
arquivo= SD.open("corrente.txt");
if(arquivo)
while(arquivo.available())
Serial.write(arquivo.read());
arquivo.close();
Serial.println("termino do arquivo 1");
arquivo2= SD.open("radi.txt");
if(arquivo2)
while(arquivo2.available())
Serial.write(arquivo2.read());
arquivo2.close();
Serial.println("termino do arquivo 2");
arquivo3= SD.open("poten.txt");
if(arquivo3)
while(arquivo3.available())
Serial.write(arquivo3.read());
arquivo3.close();
Serial.println("termino do arquivo 3");
arquivo4= SD.open("gp.txt");
if(arquivo4)
while(arquivo4.available())
Serial.write(arquivo4.read());
arquivo4.close();
Serial.println("termino do arquivo 4");
else
Serial.println("erro ao abrir arquivo para leitura");
else if (opcao == 'e') // apagar o arquivo sensor.txt
SD.remove("corrente.txt");
- 99 -
if(!SD.exists("corrente.txt"))
Serial.println("Arquivo 1 apagado com sucesso");
SD.remove("radi.txt");
if(!SD.exists("radi.txt"))
Serial.println("Arquivo 2 apagado com sucesso");
SD.remove("poten.txt");
if(!SD.exists("poten.txt"))
Serial.println("Arquivo 3 apagado com sucesso");
SD.remove("gp.txt");
if(!SD.exists("gp.txt"))
Serial.println("Arquivo 4 apagado com sucesso");
else
Serial.println("Erro ao apagar");
static void smartDelay(unsigned long ms) // a partir daqui são definidas funções para
facilitar a aquisição de dados do GPS;
unsigned long start = millis();
do
while (ss.available())
gps.encode(ss.read());
while (millis() - start < ms);
static void printFloat(float val, bool valid, int len, int prec)
if (!valid)
while (len-- > 1)
Serial.print('*');
Serial.print(' ');
else
Serial.print(val, prec);
int vi = abs((int)val);
- 100 -
int flen = prec + (val < 0.0 ? 2 : 1); // . and -
flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
for (int i=flen; i<len; ++i)
Serial.print(' ');
smartDelay(0);
static void printInt(unsigned long val, bool valid, int len)
char sz[32] = "*****************";
if (valid)
sprintf(sz, "%ld", val);
sz[len] = 0;
for (int i=strlen(sz); i<len; ++i)
sz[i] = ' ';
if (len > 0)
sz[len-1] = ' ';
Serial.print(sz);
smartDelay(0);
static void printDateTime(TinyGPSDate &d, TinyGPSTime &t)
if (!d.isValid())
Serial.print(F("********** "));
else
char sz[32];
sprintf(sz, "%02d/%02d/%02d ", d.month(), d.day(), d.year());
Serial.print(sz);
if (!t.isValid())
Serial.print(F("******** "));
else
char sz[32];
sprintf(sz, "%02d:%02d:%02d ", t.hour(), t.minute(), t.second());
Serial.print(sz);
- 101 -
printInt(d.age(), d.isValid(), 5);
smartDelay(0);
static void printStr(const char *str, int len)
int slen = strlen(str);
for (int i=0; i<len; ++i)
Serial.print(i<slen ? str[i] : ' ');
smartDelay(0);