projeto get
TRANSCRIPT
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ
CENTRO DE CIÊNCIAS EXATAS E DE TECNOLOGIA – CCET
CURSO DE ENGENHARIA DE COMPUTAÇÃO
Henrique Soares Hinke
José Eduardo da Silva Rodrigues
Matheus Augusto de Queiroz Sene
Washington Luiz Peroni
PROJETO INTEGRADO GET
Curitiba - PR 2010
2
Henrique Soares Hinke
José Eduardo da Silva Rodrigues
Matheus Augusto de Queiroz Sene
Washington Luiz Peroni
PROJETO INTEGRADO GET
Documento apresentado ao curso
Graduação em Engenharia de Computação
da Pontifícia Universidade Católica do
Paraná como requisito à avaliação da
disciplina de Resolução dos Problemas de
Engenharia II e Física IV, referente ao
projeto integrado do 2º semestre.
Professores: Afonso Ferreira Miguel
e Gil Marcos Jess.
Curitiba - PR 2010
3
DEDICATÓRIA
Dedicamos este trabalho primeiramente a Deus, pela saúde, fé e
perseverança que têm nos dado. A nossos pais, pelo reconhecimento à nossa
escolha do curso e futura profissão, e a quem honramos pelo esforço de nos
mantermos vivos em um curso com tantas dificuldades como este. A todos os
professores e professoras que muito nos ajudam para nossa futura formação, dos
quais teremos boas lembranças.
4
AGRADECIMENTOS
Nossos sinceros agradecimentos aos professores e colaboradores que
enriqueceram nosso projeto com críticas e sugestões. Em especial, os
professores Afonso Ferreira Miguel e Gil Marcos Jess. Também gostariamos de
agradecer colegas de nosso curso que nos ajudaram a superar dificuldades e
fazer com que esse projeto fosse tirado do papel, e se tornasse realidade como
desejamos.
5
SUMÁRIO
1. INTRODUÇÃO.......................................................................................................06
2. OBJETIVOS...........................................................................................................06
3. DESCRIÇÃO DO PROJETO.................................................................................07
Display LCD .....................................................................................07
Relógio RTC.......................................................................................08
Placa de Medição.............................................................................10
Arduino..............................................................................................13
Alimentação......................................................................................14
Memória............................................................................................15
Entrada e Saída................................................................................15
Comunicação....................................................................................17
Programação....................................................................................17
Segurança........................................................................................17
Características Físicas.....................................................................18
Softwares..........................................................................................18
Software de Leitura de Tensão...................................................................24
Software Interface Usuário..........................................................................25
Software de leitura e gravação cartão SD...................................................29
4. ÉTICA.....................................................................................................................34
5. PROBLEMAS ENCONTRADOS, SOLUÇÕES E CONCLUSÃO...........................34
6. REFERÊNCIAS BIBLIOGRÁFICAS.......................................................................35
7. APÊNDICE.............................................................................................................35
6
1. INTRODUÇÃO
Para o nosso segundo projeto na graduação de engenharia da
computação decidimos realizar algo que estivesse dentro de nossos
conhecimentos, que tivesse uma boa aceitação dos professores e que estivesse
dentro dos pré-requisitos de elaboração do projeto.
O projeto em questão é o GET, que é uma abreviatura para o nome
Gravador de Estado de Tensão que é um equipamento que irá gravar a tensão
contínua e nos apontar possíveis alterações na rede elétrica do ambiente que
estaremos monitorando.
Outro aspecto relevante frente ao projeto é que atualmente existe é muito
importante se medir a qualidade da energia elétrica.Determinados aparelhos são
bastante sensíveis a pequenas alterações e podem ocorrer falhas em seu
funcionamento.Alguns desses equipamentos são impressoras, equipamentos clp,
linhas de pintura e diversas máquinas que necessitem de alguma programação
antecipada, que em caso de um SAG/SWELL(quedas ou picos de tensão) podem
sofrer problemas, que levam a parada de uma linha de produção, por exemplo.
2. OBJETIVOS
O principal objetivo deste projeto é a leitura da tensão elétrica no ambiente
e tratar os números obtidos através de um software de controle, que foi feito pela
própria equipe de desenvolvimento.Outro objetivo central é, dentro da medição da
7
tensão, identificar, quando existir, o chamado SAG/SWELL que são variações
minímas na tensão elétrica que podem desestabilizar o equipamento a ser
monitorado.Logo mais, iremos detalhar a definição de SAG/SWELL.
A base do projeto é o microprocessador Arduino Duemilanove, devido a
algumas facilidades na programação e implementação do mesmo, evitar a
inserção de componentes e tratamentos adicionais além do conhecimento prévio
dos integrantes do grupo.No Arduino existe toda a programação para o
tratamento da tensão obtida, juntamente com um circuito de divisão resistiva que
realiza a leitura e passa ao Arduino realizar o tratamento
A interface homem máquina é feita pelo próprio controlador Arduino, que
possui toda a lógica de controle. Ele possui um ambiente de desenvolvimento de
suas funções que se comunica com o computador através de porta USB acoplada
na placa.Também existe um software do tratamento da tensão obtida, que nos
mostra um gráfico das últimas tensões obtidas, valores em específicos períodos
de tempo e uma análise geral da tensão no ambiente em que o GET foi utilizado.
Um dos principais desafios do projeto é aproximar valor da tensão obtida
ao mais próximo da realidade.Por se tratar de um equipamento ainda em fase
prótotipa, algumas sensíveis variações podem ocorrer e nosso foco foi para que
chegassemos o mais próximo da realidade da tensão na linha elétrica.
3. DESCRIÇÃO DO PROJETO
Em nossa descrição de projeto detalhamos tudo o que foi desenvolvido no
mesmo. Desde uma pequena explicação sobre o equipamento até a forma que
ele foi aplicado em nosso projeto.
8
Diagrama Divisor Resistivo GET
3.1) DISPLAY LCD
Um display de cristal liquido é um painel fino usado para exibir
informações por via eletrônica, como texto, imagens e vídeos.Seu uso inclui
monitores para computadores, painéis de instrumentos e outros dispositivos que
são utilizados para os mais variados fins.
Um LCD consiste de um liquido polarizador de luz, eletricamente
controlado, que se encontra comprimido dentro de celas entre duas lâminas
transparentes polarizadas.Os eixos polarizadores de duas lâminas estão
alinhados perpendicularmente entre si.Cada cela é provida de contatos elétricos
que permitem um campo elétrico possa ser aplicado ao liquido no interior.
Em nosso projeto o display LCD foi usado para mostrar ao usuário as
informações de tensão e data e hora instantânea.O tamanho escolhido foi de
acordo com as necessidades de visualização das informações.
9
Figura 1 - LCD GET
3.2) RELÓGIO RTC
Um relógio de tempo real(RTC ou real time clock, em inglês), é um
relógio de computador(geralmente sob a forma de um circuito integrado) que
mantém o controle do tempo presente.Embora o termo freqüentemente refira-se a
computadores pessoais, servidores e sistemas embarcados os RTCs estão
presente quase na totalidade dos dispositivos eletrônicos que precisam manter
um controle preciso do tempo.
Em nosso projeto, o RTC é muito importante pois é ele quem
monitora o horário e a data dos eventos medidos pelo GET.É através dele, que
podemos saber com exatidão qual o tempo de uma queda ou um pico de
energia.Para a nossa utilização ele utilizou um CI(circuito integrado) especifico,
um resistor e uma bateria.
10
A implementação foi feita sem maiores dificuldades, apenas tivemos
problemas com a bateria que apresentava defeitos.Após a troca esses defeito foi
corrigido e não apareceu novamente.
Figura 2 - RTC Ativo
3.3) PLACA DE MEDIÇÃO
A placa de medição é o coração do projeto GET, sendo assim é
parte fundamental para que o projeto cumpra as necessidades a que foi aferido.
A placa é constituída de um trafo 12+12V, um capacitor, resistores e
é ligado diretamente no Arduino.O trafo ao mesmo tempo que alimenta o Arduino,
recebe a tensão de 127V da tomada e converte em 12V, para que a leitura seja
mais precisa e mais segura.
A parte de medição da tensão, ao mesmo tempo que era nosso
principal objetivo, também foi o que mais nos causou problemas.Inicialmente
iríamos utilizar uma placa idealizada pelo Prof Ivan Chueiri, que continha um chip
denominado ADE7753, que faria a medição em tempo real e que nos ajudaria a
11
montar todo o circuito baseado apenas nesse CI.Nossa equipe se empenhou por
mais ou menos um mês em tentar fazer o chip funcionar, contando com a ajuda
de outros professores e alunos de períodos superiores.Após muito estudo,
chegamos a conclusão de que não iríamos conseguir realizar a medição com o
ADE7753 por falta de conhecimento no CI e na sua implementação.
Após tomada essa decisão, começamos a estudar a possibilidade de
usar o trafo e fazer a manipulação da tensão obtida através de software
desenvolvido internamente.Em menos de duas semanas, já conseguíamos ler
tensão na tomada.Por não se tratar de uma leitura real, como era o ADE7753,
temos algumas sensíveis variações na medição realizada com o que temos
realmente na tomada.Nos piores casos, essa tensão variou em uma margem de
3V para cima ou para baixo.Através de muita manipulação por software e nos
componentes das placas, conseguimos chegar o mais próximo do ideal possível,
conseguindo medir com quase 98% de precisão.
Acreditamos que com os conhecimentos que temos, realizamos um
grande trabalho no desenvolvimento da placa, que sem dúvida, foi nosso maior
problema.Estudamos muito, aprendemos ainda mais e soubemos recuperar o
tempo perdido com a outra forma que acabou não sendo realizada.
Como projeto futuro, pretendemos utilizar o ADE7753, mas no que
foi proposto agora, não tivemos condições de finalizar e acreditamos que a forma
que fizemos era a melhor possível.
12
Figura 3 - Placa de medição GET
3.4) ARDUINO
O Arduino é um computador físico baseado numa plataforma de
hardware livre, projetada com um microcontrolador de placa única com suporte de
entrada/saída embutido e uma linguagem de programação padrão, na qual tem
origem em Wiring e é essencialmente em C/C++, tornando mais fácil a adaptação
ao nosso projeto e ao entendimento dos integrantes da equipe.
Uma placa Arduino é composta por um controlador, algumas linhas
de E/S digital e analógica, além de uma interface serial ou USB.
A interface do hospedeiro é bastante simples, podendo ser escrita
em várias linguagens. A mais popular é denominada Processing, utilizada na
grande maioria das aplicações desenvolvidas com o Arduino.
O projeto inicial do Arduino iniciou-se na cidade de Ivrea, na Itália
em 2005, com o intuito de interagir em pequenos projetos e ter um orçamento de
desenvolvimento menor do que outros sistemas semelhantes. Seu sucesso deu-
se com uma menção honrosa na categoria de Comunidades Digitais em 2006,
13
pela Prix Ars Eletrônica, além de uma marca considerável de 75mil placas
vendidas até o meio do ano de 2009.
Para nosso projeto GET, selecionamos a placa Arduino Duemilanove,
que de acordo com estudos realizado pelos integrantes do grupo, era a placa de
melhor custo beneficio e melhor preparada para atender os requisitos do projeto.
Abaixo vão as principais características do microcontrolador utilizado no
GET:
Microcontrolador ATmega328
Tensão Operacional 5V
Tensão de alimentação (recomendada) 7-12V
Tensão de alimentação (limites) 6-20V
Pinos I/O digitais 14 (dos quais 6 podem ser saídas PWM)
Pinos de entrada analógica 6
Corrente contínua por pino I/O 40 mA
Corrente contínua para o pino 3.3V 50 mA
Memória flash 32 KB (2KB usados para o bootloader)
SRAM 2 KB
EEPROM 1 KB
Velocidade de clock 16 MHz
3.4.1) Alimentação
14
O Arduino Duemilanove pode ser alimentado pela conexão USB ou por
qualquer fonte de alimentação externa. A fonte de alimentação é selecionada
automaticamente.
A alimentação externa (SEM USB) pode ser tanto uma fonte, como uma
bateria. A fonte pode ser conectada com um plug de 2,1mm (centro positivo) no
conector de alimentação. Cabos vindos de uma bateria podem ser inseridos nos
pinos GND (terra) e VIN (entrada de tensão) do conector de alimentação.
A placa pode operar com alimentação externa de 6 a 20 Volts. Entretanto,
se a alimentação for inferior a 7V, o pino 5V poderá fornecer menos de 5V e a
placa poderá ficar instável. Se a alimentação for superior a 12V o regulador de
tensão pode superaquecer e avariar a placa, por isso a alimentação recomendada
é de 7V a 12V.
Os pinos de alimentação presentes na placa, são:
VIN: Entrada de alimentação para a placa Arduino quando
uma fonte externa for utilizada.
5V: A fonte de alimentação utilizada pelo microcontrolador e
para outros componentes da placa. Pode ser proveniente do pino VIN
através de um regulador On-board, ou ser fornecida pelo USB.
3V3: Alimentação de 3,3V fornecida pelo chip FTDI. A
corrente máxima é de 50mA.
GND: É o pino terra.
3.4.2) Memória
O ATmega328 tem 32KB de memória flash para armazenar código, além
de 2KB de SRAM e 1KB de EEPROM.
15
3.4.3) Entrada e Saída
Cada um dos 14 pinos digitais do Arduino Duemilanove podem ser usados
como entrada e saída usando as funções pinMode(), digitalWrite() e
digitalRead(). Eles operam com tensão de 5V. Cada pino pode fornecer ou
receber um máximo de 40mA e tem um resistor pull-up interno de 20-50kOhms.
Além disso, alguns pinos possuem funções especiais:
Serial 0(RX) e 1(TX): Usados para receber(RX) e
transmitir(TX) dados seriais TTL. Estes pinos são conectados aos pinos
correspondentes do chip serial FTDI USB-TTL.
Interruptores externos 2 e 3: Esses pinos podem ser
configurados para disparar uma interrupção por um baixo valor, uma
elevação, uma falha ou uma mudança de parâmetros.
PWM 3,5,6,9,10 e 11: Fornecem uma saída analógica PWM
de 8bit com a função analogWrite().
SPI 10(SS), 11(MOSI), 12(MISO), 13(SCK): Esses pinos
suportam comunicação SPI, embora seja compatível com o hardware ela
não esta disponível na linguagem do Arduino.
LED 13: Há um led já montado e conectado ao pino digital 13.
Quando o pino esta no valor HIGH, o led acende e quando esta na posição
LOW, o led apaga.
O Duemilanove possui seis entradas analógicas e em cada uma delas
existe uma resolução de 10bit. Por padrão, elas medem de 0V a 5V, embora essa
característica possa ser mudada com códigos específicos na programação do
hardware.
I²C 4(DAS) e 5(SCL): Suportam comunicação I²C(TWI)
usando a biblioteca Wire)
AREF: Referência de tensão para as entradas analógicas.
Usados com a função analogReference().
16
Reset: Esse botão tem a função de enviar um valor LOW para
reinicializar o microcontrolador.
3.4.4) Comunicação
Com o Arduino Duemilanove a comunicação com um PC, com outro
Arduino ou com outro modelo de microcontrolador é muito simples. O ATmega328
permite a comunicação serial no padrão UART TTL (5V), que está disponível nos
pinos digitais 0(RX) e 1(TX). Um chip FTDI FT232RL presente na placa,
encaminha esta comunicação serial através do USB e os drivers FTDI, que já
estão no software Arduino, fornecem uma porta COM virtual para o software no
computador. O software Arduino inclui um monitor serial que permite que dados
simples de texto sejam enviados ao Arduino. Os LEDs RX e TX da placa piscam
quando os dados estão sendo transferidos ao computador pelo chip FTDI através
da conexão USB.
O ATmega328 também oferece suporte aos padrões de comunicação
I²C(TWI) e SPI. O software do Arduino inclui uma biblioteca Wire para simplificar o
uso de I²C.
3.4.5) Programação
O Arduino Duemilanove pode ser programado com o software Arduino,
que acompanha a placa.
O ATmega328 no Arduino Duemilanove vem pré-gravado com um
bootloader que permite enviar novos programas sem o uso de um programador
de hardware externo. Ele se comunica utilizado o protocolo original STK500.
3.4.6) Segurança
17
O Arduino Duemilanove tem um polifusível resetável que protege a porta
US
B do seu computador contra curto-circuito e sobre corrente. Apesar da
maioria dos computadores possuírem proteção interna própria, o fusível
proporciona uma proteção extra. Se mais de 500mA foram aplicados na porta
USB, o fusível irá automaticamente interromper a conexão até que o curto ou a
sobrecarga seja removida.
3.4.7) Características Físicas
O comprimento e a largura máxima do Duemilanove são 2,7" (68,50 mm)
e 2,1" (53,34 mm) respectivamente, com o conector USB e o jack de alimentação
indo um pouco além destas dimensões
Figura 8 - Arduino Duemilanove 1
3.5) SOFTWARES
No projeto GET foram desenvolvidos diversos softwares para a completa
implementação do projeto.Abaixo segue um pequeno resumo de cada software
desenvolvido e seu código fonte na integra.
18
3.5.1) Software Leitura de Tensão
O software de leitura de tensão foi desenvolvido após a desistência em
utilizar o ADE7753.Ele recebe a tensão obtida pela tomada e realiza ajustes e
manipulações para que a leitura possa ser o mais precisa possível.
float getTensaoDivisor()
{
float v_divisor = (analogRead(0) * 5) / (float)1024;
return v_divisor;
}
float getTensaoCapacitor(float v_divisor)
{
float v_capacitor = (v_divisor * 31.961) / (float)2.906;
return v_capacitor;
}
float getTensaoTrafo(float v_capacitor)
{
float v_trafo = (v_capacitor / (float)sqrt(2)) + 1.4;
return v_trafo;
}
float getTensaoTomada(float v_trafo)
19
{
float v_tomada = (v_trafo * 127) / (float)24;
return v_tomada;
}
void setup()
{
Serial.begin(9600);
analogReference(DEFAULT);
pinMode(A0, INPUT);
}
void loop()
{
if(Serial.available() > 0)
{
byte input = Serial.read();
if(input == 0x00)
{
float v_divisor = getTensaoDivisor();
float v_capacitor = getTensaoCapacitor(v_divisor);
float v_trafo = getTensaoTrafo(v_capacitor);
float v_tomada = getTensaoTomada(v_trafo);
20
Serial.write(v_tomada);
}
}
/*float div = getTensaoDivisor();
float cap = getTensaoCapacitor(div);
float traf = getTensaoTrafo(cap);
float toma = getTensaoTomada(traf);
Serial.print(div);Serial.print("; ");Serial.print(cap);Serial.print(";
");Serial.print(traf);Serial.print("; ");Serial.println(toma);
delay(500);*/
3.5.2) Software de Interface ao Usuário
O software de interface junto ao usuário foi desenvolvido para que o
usuário que for medir a tensão com o GET, consiga uma melhor visualização e
entendimento dos dados obtidos através do software de análise, que facilita o
entendimento de toda a leitura realizada.
21
Ilustração 1 - Tela do Software Final
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO.Ports;
using System.IO;
namespace TesteLeitura
{
public partial class Form1 : Form
{
SerialPort portaSerial = new SerialPort("COM5", 9600);
22
byte tensaoAtual = 0;
Color corTensao = Color.Lime;
byte[] byteRequisicao = { 0x00 };
List<byte> tensoesPlotagem = new List<byte>();
int qtd = 75;
float dis = 0;
int total = 0;
int eventos = 1;
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
if (!portaSerial.IsOpen)
portaSerial.Open();
timerLeitura.Start();
timerRelogio.Start();
dis = (pictureBoxPlotagem.Width / qtd);
total = (int)(pictureBoxPlotagem.Width / dis);
}
private void timerLeitura_Tick(object sender, EventArgs e)
23
{
if (portaSerial.IsOpen)
{
portaSerial.Write(byteRequisicao, 0, byteRequisicao.Length);
if (portaSerial.BytesToRead > 0)
{
byte lido = (byte)portaSerial.ReadByte();
tensaoAtual = lido;
tensoesPlotagem.Add(tensaoAtual);
if (tensoesPlotagem.Count == total)
tensoesPlotagem.Clear();
bool evento = false;
textBoxTensao.Text = tensaoAtual.ToString() + "V";
if ((tensaoAtual > 110 && tensaoAtual < 120) || (tensaoAtual > 127 && tensaoAtual <=
135))
{
corTensao = Color.Yellow;
}
else if (tensaoAtual <= 110 || tensaoAtual > 135)
{
corTensao = Color.Red;
evento = true;
}
else
24
corTensao = Color.Lime;
if (evento)
{
ListViewItem item = new ListViewItem(eventos.ToString());
item.SubItems.Add(new ListViewItem.ListViewSubItem(item,
tensaoAtual.ToString()));
item.SubItems.Add(new ListViewItem.ListViewSubItem(item,
DateTime.Now.ToString()));
listViewEventos.Items.Add(item);
eventos++;
}
pictureBoxTensao.Invalidate();
pictureBoxPlotagem.Invalidate();
}
}
}
private void timerRelogio_Tick(object sender, EventArgs e)
{
labelHorario.Text = DateTime.Now.ToString();
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if (portaSerial.IsOpen)
25
portaSerial.Close();
timerLeitura.Stop();
}
private void pictureBoxTensao_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
desenharNivelTensao(g);
}
private void pictureBoxPlotagem_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
desenharTensoes(g);
}
private void desenharNivelTensao(Graphics g)
{
26
Rectangle rectTensao = new Rectangle(new Point(0, pictureBoxTensao.Height -
tensaoAtual), new Size(pictureBoxTensao.Width, pictureBoxTensao.Height));
g.FillRectangle(new SolidBrush(Color.FromArgb(185, corTensao)), rectTensao);
g.DrawLine(new Pen(Color.Black, 4), new Point(0, pictureBoxTensao.Height - tensaoAtual),
new Point(pictureBoxTensao.Width, pictureBoxTensao.Height - tensaoAtual));
g.DrawString("Nível de Tensão", new Font("Verdana", 12, FontStyle.Bold), Brushes.Black,
new PointF((pictureBoxTensao.Width / 2) - 75, pictureBoxTensao.Height / 2));
}
private void desenharTensoes(Graphics g)
{
float inc = 0;
List<PointF> pts = new List<PointF>();
for (int i = 0; i < tensoesPlotagem.Count; i++)
{
PointF pTensao = new PointF(inc, pictureBoxPlotagem.Height - tensoesPlotagem[i]);
pts.Add(pTensao);
inc += dis;
}
inc = 0;
if (pts.Count >= 1)
{
g.DrawLine(Pens.LightGray, new PointF(0, pictureBoxPlotagem.Height - tensaoAtual),
new PointF(pictureBoxPlotagem.Width, pictureBoxPlotagem.Height - tensaoAtual));
27
g.DrawLine(Pens.LightGray, new PointF(pts[pts.Count - 1].X, 0), new PointF(pts[pts.Count
- 1].X, pictureBoxPlotagem.Height));
}
if(pts.Count >= 2)
g.DrawCurve(Pens.Black, pts.ToArray());
for (int i = 0; i < tensoesPlotagem.Count; i++)
{
PointF pTensao = new PointF(inc, pictureBoxPlotagem.Height - tensoesPlotagem[i]);
Pen penTensao = new Pen(Color.Lime);
if ((tensoesPlotagem[i] > 110 && tensoesPlotagem[i] < 120) || (tensoesPlotagem[i] > 127
&& tensoesPlotagem[i] <= 135))
penTensao.Color = Color.Yellow;
else if (tensoesPlotagem[i] <= 110 || tensoesPlotagem[i] > 135)
penTensao.Color = Color.Red;
g.FillEllipse(penTensao.Brush, new RectangleF(new PointF(pTensao.X - 3, pTensao.Y - 3),
new SizeF(6, 6)));
inc += dis;
}
g.DrawString("Oscilografia", new Font("Verdana", 12, FontStyle.Bold), Brushes.Black, new
PointF(5, 5));
}
}
}
28
3.5.3) Software de Leitura do cartão SD
Os cartões de memória Secure Digital Card ou SD Card são uma evolução da
tecnologia MultiMediaCard (ou MMC). Adicionam capacidades de criptografia e
gestão de direitos digitais (daí o Secure), para atender às exigências da indústria
da música e uma trava para impedir alterações ou apagamento do conteúdo do
cartão, assim como os disquetes de 3½".
Se tornou o padrão de cartão de memória com melhor custo/benefício do
mercado (ao lado do Memory Stick), desbancando o concorrente Compact Flash,
devido a sua popularidade e portabilidade, e conta já com a adesão de grandes
fabricantes como Canon, Kodak e Nikon que anteriormente utilizavam
exclusivamente o padrão CF (sendo que seguem usando o CF apenas em suas
câmeras profissionais). Além disso, está presente também em palmtops, celulares
(nos modelos MiniSD, MicroSD e Transflash), sintetizadores MIDI, tocadores de
MP3 portáteis e até em aparelhos de som automotivo.
No Projeto GET o cartão SD é utilizado para armazenar todas as leituras feitas
pelo equipamento.Esses dados poderão ser lidos em qualquer computador(que
possua entrada para esse dispositivo).Escolhemos o SD pela capacidade de
armazenamento(1GB) e pela facilidade em implementação e facilidade em
encontrar computadores que possam reconhecer o dispositivo.Foi utilizado um
Shield do Arduino para que esse processo pudesse ser realizado.Esse shield
consiste em uma pequena placa adaptadora de cartão SD para o Arduino.
Abaixo a rotina de gravação dos dados obtidos pelo GET no cartão SD.
29
Ilustração 2 - Shield SD Arduino
//Add the SdFat Libraries
#include "SdFat.h"
#include "SdFatUtil.h"
#include <ctype.h>
//Create the variables to be used by SdFat Library
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;
char name[] = "Test.txt"; //Create an array that contains the name of our file.
char contents[256]; //This will be a data buffer for writing contents to the file.
30
char in_char=0;
int index=0; //Index will keep track of our position within the contents buffer.
void setup(void)
{
Serial.begin(9600); //Start a serial connection.
pinMode(10, OUTPUT); //Pin 10 must be set as an output for the SD communication to
work.
card.init(); //Initialize the SD card and configure the I/O pins.
volume.init(card); //Initialize a volume on the SD card.
root.openRoot(volume); //Open the root directory in the volume.
}
void loop(void){
file.open(root, name, O_CREAT | O_APPEND | O_WRITE); //Open or create the file 'name' in
'root' for writing to the end of the file.
sprintf(contents, "Millis: %d ", millis()); //Copy the letters 'Millis: ' followed by the integer
value of the millis() function into the 'contents' array.
file.print(contents); //Write the 'contents' array to the end of the file.
file.close(); //Close the file.
file.open(root, name, O_READ); //Open the file in read mode.
in_char=file.read(); //Get the first byte in the file.
//Keep reading characters from the file until we get an error or reach the end of the file. (This
will output the entire contents of the file).
while(in_char >=0){ //If the value of the character is less than 0 we've reached the end of
the file.
Serial.print(in_char); //Print the current character
in_char=file.read(); //Get the next character
}
31
file.close(); //Close the file
delay(1000); //Wait 1 second before repeating the process.
4. ÉTICA
O nosso projeto não visa afirmar em nenhum momento que o
desenvolvimento partiu exclusivamente dos integrantes de nossa equipe. Nesse
caso, alguns dos materiais foram retirados da Internet e publicações específicas
do que iríamos utilizar em nosso projeto. A maioria dos integrantes ainda não
possui sólidos conhecimentos em determinados assuntos que envolveram o
desenvolvimento, por isso a união e o esforço de todos foi fator determinante para
o sucesso do GET.
5. CONCLUSÃO
O presente trabalho, nosso segundo grande projeto, dentro da graduação
de engenharia da computação nos mostrou a realidade de todo grande projeto,
com altos e baixos mas que no fim a superação faz se tornar o sonho uma
realidade e graças a um esforço generalizado de todos os membros da equipe,
conseguimos finalizar o projeto e atender a expectativas de obter e tratar a leitura
da tensão.
Foi um projeto longo, trabalhoso, difícil e que exigiu muito de todos
nós.Começamos com uma proposta, como dito anteriormente, mas que por falta
de preparo e conhecimento de todos os membros da equipe, decidimos realizar
uma mudança substancial no projeto, que fez com que ele saísse perfeitamente e
talvez até melhor do que antes projetado.
Obtivemos uma leitura de aproximadamente 98% de precisão da tensão,
gravando em um cartão SD, mostrando em tempo real em um display LCD e
sendo manipulado e tratado em um software criado internamente. E com isso
acreditamos que conseguimos atingir todos os objetivos do projeto.
32
O projeto não teria sido finalizado da maneira correta sem o total
envolvimento de todos os membros do grupo, dos professores que nos ajudaram
bastante e da infra-estrutura da Universidade.
Com o projeto, acrescentamos conhecimento nas disciplinas de Sistemas
Digitais, Circuitos Elétricos, Eletrônica,Física e na forma de gerenciar um projeto,
desde a elaboração de um cronograma, custos, divisão de responsabilidades e
execução das atividades no tempo proposto pelo professor.
Esperamos que o Projeto GET seja apenas mais um passo em nossa
graduação, que seja mais um projeto vitorioso em nossas carreiras dentro e fora
da Universidade.
6. REFERENCIAS
Site acessado em 20/08/2010 – http://www.arduino.cc/en
Site acessado em 25/09/2010 – http://interactive-matter.org/2009/12/shield
sdarduino/comment-page-1/
Site acessado em 27/08/2010 - www.aneel.gov.br
Site acessado em 17/08/2010 - http://www2.eletronica.org/forum-de-
discussoes/geral/933750840
Site acessado em 09/09/2010 - en.wikipedia.org/wiki/Real-time_clock
7. APÊNDICE
Segue anexo em formato digital.