SISTEMA DE MONITORAMENTO E REGISTRO DE DADOS … · PROJETO DE GRADUAÇÃO SUBMETIDO AO CORPO DOCENTE DO CURSO DE ... usados nesse trabalho foram um sensor de corrente Allegro ACS758,

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.

http://forum.iteadstudio.com/viewtopic.php?f=25&t=759

- 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


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.




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);


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);




inicio_ok=0;

return;


void loop()



o envio para a tela



- 86 -



loop esperando vc configurar o tempo que quer








while(opcao != 'x') // Vai ficar lendo o sensor e salvando até que aperte o x para

sair


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(corrente);

arquivo.println(" A");

arquivo.close();


Serial.print("Feita leitura da corrente em ");



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 -


Serial.print("Feita leitura da radiacao em ");



Serial.print("Radiacao = ");

Serial.print(pira);

Serial.println(" W/m²");


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(poten);

arquivo3.println(" W");

arquivo3.close();


Serial.print("Feita leitura da potencia em ");



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


momento

Serial.println("Terminando Leitura dos sensores");


arquivo= SD.open("corrente.txt");

if(arquivo)



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();


arquivo3= SD.open("poten.txt");

if(arquivo3)



arquivo3.close();


else


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"))


SD.remove("poten.txt");

if(!SD.exists("poten.txt"))


else


- 89 -

Anexo III

Programa de Leitura e Armazenamento de dados do GPS Shield [13].



#include <TinyGPS++.h>

#include <SoftwareSerial.h>


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()


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;



inicio_ok=0;

return;

- 90 -


void loop()



o envio para a tela





loop esperando você configurar o tempo que quer







if(opcao == 'w')


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();


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


salvar


momento


if(opcao =='r') // mostra o que foi salvo no arquivo txt do SD

arquivo= SD.open("gp.txt");

if(arquivo)



arquivo.close();


else


else if (opcao == 'e') // apagar o arquivo txt

SD.remove("gp.txt");

if(!SD.exists("gp.txt"))


- 92 -

else


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 <TinyGPS++.h>

#include <SoftwareSerial.h>


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()



calibracao=analogRead(A0); // calibração do sensor de corrente sem corrente

if (calibracao)



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;




inicio_ok=0;

return;


void loop()



o envio para a tela





loop esperando vc configurar o tempo que quer









sair


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(corrente);

arquivo.println(" A");

arquivo.close();


Serial.print("Feita leitura da corrente em ");



Serial.print("Corrente = ");

Serial.print(corrente);

Serial.println(" A");


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(pira);

arquivo2.println(" W/m²");

arquivo2.close();


Serial.print("Feita leitura da radiacao em ");



Serial.print("Radiacao = ");

Serial.print(pira);

Serial.println(" W/m²");


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 ");



- 97 -

arquivo3.println(poten);

arquivo3.close();


Serial.print("Feita leitura da potencia em ");



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();


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


salvar

- 98 -


momento



arquivo= SD.open("corrente.txt");

if(arquivo)



arquivo.close();


arquivo2= SD.open("radi.txt");

if(arquivo2)



arquivo2.close();


arquivo3= SD.open("poten.txt");

if(arquivo3)



arquivo3.close();


arquivo4= SD.open("gp.txt");

if(arquivo4)



arquivo4.close();


else


else if (opcao == 'e') // apagar o arquivo sensor.txt

SD.remove("corrente.txt");

- 99 -

if(!SD.exists("corrente.txt"))


SD.remove("radi.txt");

if(!SD.exists("radi.txt"))


SD.remove("poten.txt");

if(!SD.exists("poten.txt"))


SD.remove("gp.txt");

if(!SD.exists("gp.txt"))


else


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);

Documents

SISTEMA DE MONITORAMENTO E REGISTRO DE DADOS … · PROJETO DE GRADUAÇÃO SUBMETIDO AO CORPO DOCENTE DO CURSO DE ... usados nesse trabalho foram um sensor de corrente Allegro ACS758,