EPD II

Frequencímetro Digital
Engenharia de Processamento Digital II

Paulo Augusto Garay Marcio Couto da Rosa Luis Fernando Espinosa Cocian
Graduando do Curso de Engenharia Graduando do Curso de Engenharia Professor do Departamento de
Elétrica Elétrica Engenharia Elétrica
Universidade Luterana do Brasil Universidade Luterana do Brasil Universidade Luterana do Brasil
Canoas, Brasil Canoas, Brasil Canoas, Brasil
pauloagaray@gmail.com marcio.eletrica@gmail.com cocian@ulbra.edu.br

Resumo – Este trabalho referente a disciplina de poderá ser manipulada. Usa-se o nível de acesso mais
Engenharia de Processamento Digital II do Curso de restritivo, private, que faça sentido para um membro
Engenharia Elétrica da Ulbra apresenta um software de particular. Sempre private, a menos que tenha um bom
desenvolvimento de um frequencimetro digital, que através motivo para deixá-lo com outro nível de acesso. Não se
de um supervisório faz a comunicação e aquisição de dados
através de uma interface visual orientada a objetos. O
deve permitir o acesso público aos membros, exceto em
desenvolvimento do software, monitoramento e aquisição de caso de ser constantes. Isso porque membros públicos
dados é feito através de uma interface visual simples tendem a nos ligar a uma implementação em particular e
orientada a objetos. O software possui duas classes que tem limita a flexibilidade em mudar o código.
características onde a classe mais complexa usa o conceito de O Encapsulamento é dividido em dois níveis:
herança da classe menos complexa, além de permitir a Nível de classe: Quando se determina o acesso de uma
alocação de dados em memória permitindo assim a gravação classe inteira que pode ser public ou private (padrão);
e leitura em um arquivo. Com a construção da interface Nível de membro: Quando se determina o acesso de
gráfica, edição do código fonte e aquisição do sinal do
atributos ou métodos de uma classe que podem ser public,
gerador de funções, o software apresentou resultados
satisfatórios diante da proposta inicial do trabalho, onde o private ou protectec. Para ter um método encapsulado
mesmo tinha o objetivo de realizar a coleta e controle dos utiliza-se um modificador de acesso que geralmente é
dados enviados a placa. public, além do tipo de retorno dele. Para se ter acesso a
algum atributo ou método que esteja encapsulado utiliza-
Palavras Chaves – Monitoramento, aquisição de dados, se o conceito de get e set. Por definição, com SET é feita
interface gráfica. uma atribuição a algum atributo, ou seja, define, diz o
valor que algum atributo deve ter. E com GET é possível
recuperar esse valor a partir do momento que temos a
I. INTRODUÇÃO disposição uma coleção de classes devidamente testadas e
com um funcionamento a prova de erros, para criar novos
A programação Orientada a objetos surgiu com o principal sistemas basta usar estas classes, sem nenhuma
objetivo de unir os dados e funções em um único necessidade de reescrever e adaptar código. Isto dá, sem
elemento: o objeto. Esta metodologia utilizada traz uma sombra de dúvida, maior rapidez e, conseqüentemente,
série de vantagens sobre outras linguagens de produtividade, produtividade no desenvolvimento de
programação, como: sistemas.
Reusabilidade: as classes que compõem um sistema
podem ser aproveitadas em outros sistemas, sem qualquer
alteração, pois dados e funções estão contidos dentro da
classe. Caso haja necessidade, podem-se criar novas
classes baseadas em outras já existentes, herdando as
características da classe pai.
Encapsulamento: vem de encapsular, que em
programação orientada a objetos significa separar o
programa em partes, o mais isolado possível. A idéia é
tornar o software mais flexível, fácil de modificar e de
criar novas implementações. O Encapsulamento serve para
controlar o acesso aos atributos e métodos de uma classe.
É uma forma eficiente de proteger os dados manipulados
dentro da classe, além de determinar onde esta classe

Paulo Garay e Marcio Couto

1
 EPD II
II. DESENVOLVIMENTO voidcEquipamento::setFabricante(std::string fabricante){
Este trabalho, requisito à conclusão da disciplina de Fabricante= fabricante;
Engenharia de Processamento Digital II, consiste no }
desenvolvimento de um software com a utilização da std::stringcEquipamento::getNomeInstrumento(){
linguagem de programação C++ através de programação returnNomeInstrumento;
orientada a objetos, desenvolvido em ambiente Microsoft }
Windows 10, utilizando-se o compilador C++ Builder da std::stringcEquipamento::getFabricante(){
empresa Borland. Foi utilizada também a plataforma de return Fabricante;
desenvolvimento Arduino Uno dotada de um Micro }
controlador da Atmel AVR.
O projeto foi implementado por software supervisório Classe cFrequencimetro:
que realiza comunicação através de interface serial USB
entre o Notebook e a placa Arduino Uno. Como hardware voidcFrequencimetro::setFaixaTrabalho(float
foi utilizado um gerador de funções que irá variar a _limiteInferior, float _limiteSuperior){
freqüência para a leitura do software através do arduino. limiteInferior = _limiteInferior;
Através do gerador, a freqüência é aplicada ao canal limiteSuperior = _limiteSuperior;
analógico do controlador, convertendo digitalmente e }
enviando o sinal ao notebook através do canal de floatcFrequencimetro::getlimiteInferior(){
comunicação serial USB, imprimindo na tela a freqüência returnlimiteInferior;
lida em um display através de um gráfico e um log de }
registros. No software é possível configurar o número de floatcFrequencimetro::getlimiteSuperior(){
leituras desejadas e o intervalo entre cada leitura. Também returnlimiteSuperior;
é possível salvar o registro de leituras em um arquivo, ou }
até, abrir leituras realizadas anteriormente.
IV. DESCRIÇAO DAS TELAS DO SUPERVISORIO
III. DESCRIÇÃO DAS CLASSES A seguir as seqüências das telas de configurações
Para o projeto, foram criadas duas classes, necessárias para o início do programa.
Cequipamento e Cfrequencimentro. A classe
Cfrequencimentro herda a metodologia da classe
Cequipamento e faz com que a classe Cfrequencimentro
obtenha todos os dados da classe Cequipamento.
. A classe Cequipamento implementa a funções
getNomeInstrumento e getFabricante e
setNomeInstrumento e getFabricante. A função
setNomeInstrumento e setFabricante escreve o nome
fornecido pelo usuário e a função getNomeInstrumento e
getFabricante lê o nome fornecido e retorna o nome a
variáveis NomeInstrumento e fabricante. Fig. 1. Tela inicial
A classe Cfrequencimentro serve para definir a faixa
de trabalho do equipamento. Utiliza a função Esta tela (Fig. 1) é a tela onde será feito o acesso aos
setFaixatrabalho, onde define o limite inferior e superior e menus, comunicação e visualização da freqüência lida.
getLimitesuperior e getlimiteInferior lêem e retorna as
variáveis os valores escritos.
As UMLs são modelos organizacionais padronizados
que retratam a essência do programa, onde os objetivos
são especificar, documentar, estruturar para sub-
visualização e proporcionar maior visualização lógica do
desenvolvimento completo do sistema de informação,
facilitando a compreensão dos problemas, equalizando a
comunicação entre técnico e usuário.
Abaixo é mostrado a UML das classes desenvolvidas e
suas configurações:

Classe cequipamento:

voidcEquipamento::setNomeInstrumento(std::string
nome){
NomeInstrumento = nome; Fig. 2. Botão configurar
}

Paulo Garay e Marcio Couto

2
 EPD II
Esta tela (Fig. 2) é responsável por iniciar e encerrar
a comunicação serial. Selecionando o botão configurar é
possível selecionar a porta adequada, velocidade de
conexão, data bits, stop bits, parity e flow control. A
conexão é realizada através dos botões “Conectar” e
“Desconectar”.
 Botão Conectar – Abre a comunicação serial e
mostra as telas de parametrização da mesma.
 Botão Desconectar – Encerra a comunicação
serial, limpando o log de registro e apaga os
dados do gráfico.
Esta tela também permite com que o usuário
selecione e configure a parametrização da comunicação
serial entre o hardware Arduino Uno e o Notebook. Esta
caixa de diálogo é de responsabilidade da biblioteca de
comunicação ComportLib.

Fig. 4. Log

Pressionando o botão Log (fig.4) encontra-se um

“memo log” onde é registrado os dados recebidos na
Fig. 3. Gráfico entrada do hardware (gerador de funções) para
visualização do usuário. Os dados mostrados neste memo
Pressionando o botão Gráfico (fig. 3) encontra-se um são salvos em um arquivo, sendo possível abrir arquivos
Tchart com a sua função de mostrar a evolução da salvos anteriormente.
aquisição de dados ao longo do tempo. A escala do eixo
vertical (Y) vai de 0 a 1023 (10 bits) e o eixo horizontal
(X) é determinado pelo número de leituras.

Fig. 5. Arquivo

Utilizando o menu do supervisório do frequencimetro

temos o Aba arquivo, onde tem a opção sair caso o
usuário queira encerrar o programa.

Fig.6. Comunicação

Paulo Garay e Marcio Couto

3
 EPD II
Na figura 6 mostra o menu comunicação onde tem a
aba configurar, que tem o mesmo comando do botão.

Fig. 7. Janelas Fig.9. O projeto

Na figura 7 mostra o menu janelas onde tem a aba log

e gráficos, que tem o mesmo comando do botão.

VI. CONCLUSÕES

Este projeto foi extrema valia para o nosso

conhecimento em programação orientada a objetos.
Tivemos que definir qual trabalho fazer, suas funções e o
melhor meio de acesso para controlar o equipamento.
Servirá para a nossa experiência em produzir
equipamentos ou soluções para problemas em nossa vida
profissional como engenheiros.
Fig. 8. Ajuda

Na figura 8 mostra o menu ajuda onde tem a aba VII. REFERÊNCIAS

sobre, onde mostra informações sobre os desenvolvedores
do projeto. [1] Cocian, Luis Fernando Espinosa - Engenharia de
processamento digital II. Canoas: Ed. ULBRA, 2006.
V. HARDWARE
Composto pela plataforma de desenvolvimento Uno, VIII. ANEXOS
possui um ATMEGA328 de 8 bits da família AVR com
arquitetura RISC avançada e com encapsulamento com 32 Programa:
KB de Flash (mas 512 Bytes são utilizados pro
bootloader), 2KB de RAM e 1KB de EEPROM. Pode frequencimetro.cpp
operar em até 20 MHz, porém o Arduino UNO opera em //--------------------------------------------------------------------
16MHz, valor do cristal externo que está conectado aos -------
pinos 9 e 10 do microcontrolador. Possui 28 pinos, sendo
que 23 desse como I/O. Esse microcontrolador pode #include <vcl.h>
operar com tensões bem baixas, de até 1,8. Possui dois #pragmahdrstop
modos de consumo super baixos, o Power-down Mode e o
Power para que o sistema possa poupar energia em #include "frequencimetro.h"
situações de espera. Possui, como periférico a USART #include "cFrequencimetro.h"
que funciona a até 250kbps, uma SPI, que vai até 5 MHz, #include "sobre.h"
e uma I2C que pode operar até 400kHz. Conta com um #include "grafico.h"
comparador analógico interno ao CI e diversos timers #include "log.h"
além de 6 WMs. A corrente máxima por pino é de 40MA, #include "dadosEquipamento.h"
mas a soma da corrente de todo o CI não pode ultrapassar //--------------------------------------------------------------------
200Ma. Ele possui um oscilador interno de 32kHz que -------
pode ser utilizado, por exemplo, em situações de baixo #pragmapackage(smart_init)
consumo. #pragma link "CPort"
Foi utilizado um gerador de funções para simular uma #pragmaresource "*.dfm"
onda quadrada com freqüência entre 1 Hz e 1kHz TFormInicial *FormInicial;

//variáveis globais

Paulo Garay e Marcio Couto

4
 EPD II
cFrequencimetro * freq; //ponteiro para o objeto da classe StatusBar1->Panels->Items[1]->Text = "Status:
cFrequencimetro Conectado";
}
//-------------------------------------------------------------------- //--------------------------------------------------------------------
------- -------
__fastcallTFormInicial::TFormInicial(TComponent*
Owner) void
: TForm(Owner) __fastcallTFormInicial::ButtonDesconectarClick(TObject
{ *Sender)
} {
//-------------------------------------------------------------------- ComPort1->Connected = false;
------- StaticText1->Caption = "FREQUENCIMETRO";
ButtonConectar->Enabled = true;
void __fastcallTFormInicial::FormCreate(TObject Conectar1->Enabled = true;
*Sender) ButtonDesconectar->Enabled = false;
{ Desconectar1->Enabled = false;
//construindo o objeto StatusBar1->Panels->Items[1]->Text = "Status:
freq = new cFrequencimetro; Desconectado";
freq->setFaixaTrabalho(0,1000); }
freq->setNomeInstrumento("Frequêncimetro de //--------------------------------------------------------------------
Bancada"); -------
freq->setFabricante("Paulo & Marcio");
void __fastcallTFormInicial::ComPort1RxChar(TObject
*Sender, intCount)
limiteInferior = freq->getlimiteInferior(); {
limiteSuperior = freq->getlimiteSuperior(); //pega o tempo corrente
fabricante = freq->getFabricante().c_str(); String tempo = TimeToStr(Time());
String leitura; //variável que guarda o retorno da serial
//imprime statusBar e staticText String registro; //variável para montar a string para o log
StaticText1->Caption = "FREQUENCIMETRO"; ComPort1->ReadStr(leitura,Count);
StatusBar1->Panels->Items[0]->Text = "Porta:"; //testa se retornou dados
StatusBar1->Panels->Items[1]->Text = "Status:"; if (leitura.Length()>0){
} frequencia = atof(leitura.c_str()); //atof converte
//-------------------------------------------------------------------- AnsiString para float
------- StaticText1->Caption = FloatToStr(frequencia) + " Hz";
// insere uma medição de frequência no form do
void gráfico
__fastcallTFormInicial::ButtonConfigurarClick(TObject if (FormGrafico->Showing){ //verifica se o form está
*Sender) sendo exibido
{ FormGrafico->Series1->Add(frequencia, tempo, clRed);
ComPort1->ShowSetupDialog(); }
if (ComPort1->Port != EmptyStr){ //selecionou uma porta // insere um registro no form de log
na lista if (FormLog->Showing){ //verifica se o form está sendo
ButtonConectar->Enabled = true; exibido
Conectar1->Enabled = true; //monto a mensagem para ser guardada
StatusBar1->Panels->Items[0]->Text = "Porta: registro = "["+tempo+"] - "+FloatToStr(frequencia)+"
"+ComPort1->Port; Hz";
} FormLog->MemoRegistros->Lines->Add(registro);
} }
//-------------------------------------------------------------------- }
------- }
//--------------------------------------------------------------------
void -------
__fastcallTFormInicial::ButtonConectarClick(TObject
*Sender)
{ void __fastcallTFormInicial::FormClose(TObject
ComPort1->Connected = true; *Sender, TCloseAction&Action)
ButtonConectar->Enabled = false; {
Conectar1->Enabled = false; //chama o método destrutor da classe
ButtonDesconectar->Enabled = true; freq->~cFrequencimetro();
Desconectar1->Enabled = true;
Paulo Garay e Marcio Couto
5
 EPD II
// verifica quais forms estão ativos e deleta }
if (FormSobre) delete FormSobre; //--------------------------------------------------------------------
if (FormLog) delete FormLog; -------
if (FormGrafico) delete FormGrafico;
} void __fastcallTFormInicial::ButtonLogClick(TObject
//-------------------------------------------------------------------- *Sender)
------- {
if (!FormLog->Showing){ //se o formLog não esta aberto
void __fastcallTFormInicial::Sobre1Click(TObject FormLog->Show(); //exibe
*Sender) //reposiciona o form
{ FormLog->Left = FormInicial->Left;
//exibe o form de sobre FormLog->Top = FormInicial->Top+FormInicial-
FormSobre->ShowModal(); >Height+1;
} }
else
//-------------------------------------------------------------------- FormLog->BringToFront(); //trás a frente
------- }
void //--------------------------------------------------------------------
__fastcallTFormInicial::ComPort1AfterOpen(TObject -------
*Sender)
{ void __fastcallTFormInicial::Grfico1Click(TObject
if (FormLog->Showing){ //verifica se o form está sendo *Sender)
exibido {
FormLog->MemoRegistros->Lines->Add("Coleta de ButtonGrafico->Click();
dados inicializado: "+TimeToStr(Time())); }
FormLog->MemoRegistros->Lines- //--------------------------------------------------------------------
>Add("==================================== -------
====");
} void __fastcallTFormInicial::Log1Click(TObject
} *Sender)
//-------------------------------------------------------------------- {
------- ButtonLog->Click();
}
void //--------------------------------------------------------------------
__fastcallTFormInicial::ComPort1AfterClose(TObject -------
*Sender)
{ void __fastcallTFormInicial::Sair1Click(TObject
if (FormLog->Showing){ //verifica se o form está sendo *Sender)
exibido {
FormLog->MemoRegistros->Lines->Add("Coleta de if( Application->MessageBox("Deseja encerrar a
dados finalizada: "+TimeToStr(Time())); aplicação?", "Encerrar Aplicação", MB_YESNO |
FormLog->MemoRegistros->Lines- MB_ICONQUESTION) == IDYES ){
>Add("==================================== if (ComPort1->Connected) //verifica se a porta está aberta
===="); ComPort1->Connected = false; //fecha a porta
} Application->Terminate(); //encerra a aplicação
} }
//-------------------------------------------------------------------- }
------- //--------------------------------------------------------------------
-------
void __fastcallTFormInicial::ButtonGraficoClick(TObject
*Sender)
{ void
if (!FormGrafico->Showing){ //se o formGrafico não esta __fastcallTFormInicial::DadosEquipamento1Click(TObje
aberto ct *Sender)
FormGrafico->Show(); //exibe {
FormGrafico->Left = FormInicial->Left+FormInicial- FormDadosEquipamento->ShowModal();
>ClientWidth+1; }
FormGrafico->Top = FormInicial->Top; //--------------------------------------------------------------------
} -------
else
FormGrafico->BringToFront(); //trás a frente
Paulo Garay e Marcio Couto
6
 EPD II
frequencimetro.h void __fastcallButtonGraficoClick(TObject *Sender);
//-------------------------------------------------------------------- void __fastcallButtonLogClick(TObject *Sender);
------- void __fastcall Grfico1Click(TObject *Sender);
void __fastcall Log1Click(TObject *Sender);
#ifndeffrequencimetroH void __fastcall Sair1Click(TObject *Sender);
#define frequencimetroH void __fastcall DadosEquipamento1Click(TObject
//-------------------------------------------------------------------- *Sender);
------- private: // Userdeclarations
#include <Classes.hpp> public: // Userdeclarations
#include <Controls.hpp> __fastcallTFormInicial(TComponent* Owner);
#include <StdCtrls.hpp> floatfrequencia;
#include <Forms.hpp> floatlimiteInferior, limiteSuperior;
#include <ComCtrls.hpp> String fabricante;
#include <Menus.hpp>
#include <ExtCtrls.hpp> };
#include "CPort.hpp" //--------------------------------------------------------------------
#include <Chart.hpp> -------
#include <Series.hpp> extern PACKAGE TFormInicial *FormInicial;
#include <TeEngine.hpp> //--------------------------------------------------------------------
#include <TeeProcs.hpp> -------
#include <Dialogs.hpp> #endif
//--------------------------------------------------------------------
-------
classTFormInicial : publicTForm cEquipamento.cpp
{ //--------------------------------------------------------------------
__published: // IDE-managedComponents -------
TStatusBar *StatusBar1;
TMainMenu *MainMenu1;
TMenuItem *Arquivo1; #pragmahdrstop
TMenuItem *Sair1;
TMenuItem *Comunicao1; #include "cEquipamento.h"
TMenuItem *Conectar1; cEquipamento::cEquipamento(){} //construtor padrão
TMenuItem *Desconectar1; da classe
TMenuItem *Configurar1; cEquipamento::cEquipamento(std::string nome){
TMenuItem *Ajuda1; //sobrecarga do construtor
TMenuItem *Sobre1; NomeInstrumento = nome;
TComPort *ComPort1; }
TPanel *Panel1; cEquipamento::~cEquipamento(){} //destrutor padrão da
TPanel *Panel2; classe
TButton *ButtonConfigurar;
TButton *ButtonConectar;
TButton *ButtonDesconectar; voidcEquipamento::setNomeInstrumento(std::string
TButton *ButtonGrafico; nome){
TButton *ButtonLog; NomeInstrumento = nome;
TMenuItem *Janelas1; }
TMenuItem *Grfico1; voidcEquipamento::setFabricante(std::string fabricante){
TMenuItem *Log1; Fabricante= fabricante;
TStaticText *StaticText1; }
TMenuItem *DadosEquipamento1;
void __fastcallFormCreate(TObject *Sender); std::stringcEquipamento::getNomeInstrumento(){
void __fastcallButtonConfigurarClick(TObject *Sender); returnNomeInstrumento;
void __fastcallButtonConectarClick(TObject *Sender); }
void __fastcallButtonDesconectarClick(TObject std::stringcEquipamento::getFabricante(){
*Sender); return Fabricante;
void __fastcall ComPort1RxChar(TObject *Sender, }
intCount);
void __fastcallFormClose(TObject *Sender, //--------------------------------------------------------------------
TCloseAction&Action); -------
void __fastcall Sobre1Click(TObject *Sender);
void __fastcall ComPort1AfterOpen(TObject *Sender); #pragmapackage(smart_init)
void __fastcall ComPort1AfterClose(TObject *Sender);
Paulo Garay e Marcio Couto
7
 EPD II
//--------------------------------------------------------------------
cEquipamento.h -------
//--------------------------------------------------------------------
------- #pragmapackage(smart_init)

#ifndefcEquipamentoH
#define cEquipamentoH cFrequencimetro.h
#include <string> //biblioteca para usar string //--------------------------------------------------------------------
-------

classcEquipamento{ #ifndefcFrequencimetroH
public: #define cFrequencimetroH
cEquipamento(); //construtor padrão da classe #include <string> //biblioteca para usar string
cEquipamento(std::string nome); //sobrecarga do
construtor //uso de herença da classe cEquipamento
~cEquipamento(); //destrutor padrão da classe #include "cEquipamento.h"

//métodos de escrita classcFrequencimetro: publiccEquipamento{

voidsetNomeInstrumento(std::string nome); public:
voidsetFabricante(std::string fabricante); cFrequencimetro(); //construtor padrão da classe
~cFrequencimetro(); //destrutor padrão da classe
//métodos de leitura
std::stringgetNomeInstrumento(); //métodos set
std::stringgetFabricante(); voidsetFaixaTrabalho(floatlimiteInferior,
floatlimiteSuperior);

private: floatgetlimiteInferior();
std::stringNomeInstrumento, Fabricante; floatgetlimiteSuperior();
};
//-------------------------------------------------------------------- private:
------- floatlimiteInferior, limiteSuperior;
#endif };
//--------------------------------------------------------------------
-------
cFrequencimetro.cpp #endif
//--------------------------------------------------------------------
-------
#pragmahdrstop dadosEquipamento.cpp
#pragmahdrstop
#include "cFrequencimetro.h"
///#include "frequencimetro.h" #include "dadosEquipamento.h"
cFrequencimetro::cFrequencimetro(){} //construtor #include "frequencimetro.h"
padrão da classe //--------------------------------------------------------------------
cFrequencimetro::~cFrequencimetro(){} //destrutor -------
padrão da classe #pragmapackage(smart_init)
#pragmaresource "*.dfm"
TFormDadosEquipamento *FormDadosEquipamento;
voidcFrequencimetro::setFaixaTrabalho(float //--------------------------------------------------------------------
_limiteInferior, float _limiteSuperior){ -------
limiteInferior = _limiteInferior; __fastcallTFormDadosEquipamento::TFormDadosEquipa
limiteSuperior = _limiteSuperior; mento(TComponent* Owner)
} : TForm(Owner)
{
floatcFrequencimetro::getlimiteInferior(){ }
returnlimiteInferior; //--------------------------------------------------------------------
} -------
floatcFrequencimetro::getlimiteSuperior(){ void
returnlimiteSuperior; __fastcallTFormDadosEquipamento::FormShow(TObject
} *Sender)
{
//carrega informações do formInicial
Paulo Garay e Marcio Couto
8
 EPD II
LabelFabricante->Caption = FormInicial->fabricante; //--------------------------------------------------------------------
LabelLI->Caption = FloatToStr(FormInicial- -------
>limiteInferior);
LabelLS->Caption = FloatToStr(FormInicial- #include <vcl.h>
>limiteSuperior); #pragmahdrstop
}
//-------------------------------------------------------------------- #include "grafico.h"
------- //--------------------------------------------------------------------
void -------
__fastcallTFormDadosEquipamento::Button1Click(TObje #pragmapackage(smart_init)
ct *Sender) #pragmaresource "*.dfm"
{ TFormGrafico *FormGrafico;
Close(); //--------------------------------------------------------------------
} -------
//-------------------------------------------------------------------- __fastcallTFormGrafico::TFormGrafico(TComponent*
------- Owner)
: TForm(Owner)
{
dadosEquipamento.h }
//-------------------------------------------------------------------- //--------------------------------------------------------------------
------- -------
void __fastcallTFormGrafico::Button1Click(TObject
#ifndefdadosEquipamentoH *Sender)
#define dadosEquipamentoH {
//-------------------------------------------------------------------- Close();
------- }
#include <Classes.hpp> //--------------------------------------------------------------------
#include <Controls.hpp> -------
#include <StdCtrls.hpp>
#include <Forms.hpp>
//-------------------------------------------------------------------- grafico.h
------- //--------------------------------------------------------------------
classTFormDadosEquipamento : publicTForm -------
{
__published: // IDE-managedComponents #ifndefgraficoH
TLabel *Label1; #define graficoH
TLabel *LabelLI; //--------------------------------------------------------------------
TLabel *Label3; -------
TLabel *Label4; #include <Classes.hpp>
TLabel *LabelLS; #include <Controls.hpp>
TLabel *Label6; #include <StdCtrls.hpp>
TLabel *LabelFabricante; #include <Forms.hpp>
TButton *Button1; #include <Chart.hpp>
void __fastcallFormShow(TObject *Sender); #include <ExtCtrls.hpp>
void __fastcall Button1Click(TObject *Sender); #include <Series.hpp>
private: // Userdeclarations #include <TeEngine.hpp>
public: // Userdeclarations #include <TeeProcs.hpp>
__fastcallTFormDadosEquipamento(TComponent* //--------------------------------------------------------------------
Owner); -------
}; classTFormGrafico : publicTForm
//-------------------------------------------------------------------- {
------- __published: // IDE-managedComponents
extern PACKAGE TFormDadosEquipamento TPanel *Panel1;
*FormDadosEquipamento; TChart *Chart1;
//-------------------------------------------------------------------- TLineSeries *Series1;
------- TButton *Button1;
#endif void __fastcall Button1Click(TObject *Sender);
private: // Userdeclarations
public: // Userdeclarations
grafico.cpp __fastcallTFormGrafico(TComponent* Owner);
};
Paulo Garay e Marcio Couto
9
 EPD II
//-------------------------------------------------------------------- void __fastcallTFormLog::ButtonLimparClick(TObject
------- *Sender)
extern PACKAGE TFormGrafico *FormGrafico; {
//-------------------------------------------------------------------- if( Application->MessageBox("Deseja limpar o arquivo
------- de log?", "Arquivo de Log", MB_YESNO |
#endif MB_ICONQUESTION) == IDYES )
MemoRegistros->Clear();
}
log.cpp //--------------------------------------------------------------------
//-------------------------------------------------------------------- -------
------- void __fastcallTFormLog::printCabecalho()
{
#include <vcl.h> MemoRegistros->Clear();
#pragmahdrstop MemoRegistros->Lines-
>Add("====================================
#include "log.h" ====");
//-------------------------------------------------------------------- MemoRegistros->Lines->Add("..:: Frequêncimetro
------- Digital Arduino ::..");
#pragmapackage(smart_init) MemoRegistros->Lines-
#pragmaresource "*.dfm" >Add("====================================
TFormLog *FormLog; ====");
//-------------------------------------------------------------------- MemoRegistros->Lines->Add("Coleta de dados
------- inicializada: "+TimeToStr(Time()));
__fastcallTFormLog::TFormLog(TComponent* Owner) }
: TForm(Owner) void __fastcallTFormLog::FormShow(TObject *Sender)
{ {
} printCabecalho();
//-------------------------------------------------------------------- }
------- //--------------------------------------------------------------------
void __fastcallTFormLog::ButtonSalvarClick(TObject -------
*Sender) void __fastcallTFormLog::ButtonFecharClick(TObject
{ *Sender)
//direciona para a pasta Medições que esta junto ao {
executável Close();
SaveDialog1->InitialDir = ExtractFilePath(Application- }
>ExeName)+"\Medições"; //--------------------------------------------------------------------
//se executou o SaveDialog, ou seja, mandou salvar -------
if (SaveDialog1->Execute()){
MemoRegistros->Lines->SaveToFile(SaveDialog1-
>FileName); log.h
ShowMessage("Arquivo de medições salvo."); //--------------------------------------------------------------------
} -------
}
//-------------------------------------------------------------------- #ifndeflogH
------- #define logH
void __fastcallTFormLog::ButtonCarregarClick(TObject //--------------------------------------------------------------------
*Sender) -------
{ #include <Classes.hpp>
OpenDialog1->InitialDir = ExtractFilePath(Application- #include <Controls.hpp>
>ExeName)+"\Medições"; #include <StdCtrls.hpp>
//se executou o OpenDialog, ou seja, mandou abrir um #include <Forms.hpp>
arquivo #include <ExtCtrls.hpp>
if (OpenDialog1->Execute()){ #include <Dialogs.hpp>
MemoRegistros->Lines->LoadFromFile(OpenDialog1- //--------------------------------------------------------------------
>FileName); -------
ShowMessage("Arquivo de medições carregado."); classTFormLog : publicTForm
} {
} __published: // IDE-managedComponents
//-------------------------------------------------------------------- TPanel *Panel4;
------- TMemo *MemoRegistros;
TButton *ButtonLimpar;
Paulo Garay e Marcio Couto
10
 EPD II
TButton *ButtonSalvar; Application->ShowException(&exception);
TButton *ButtonCarregar; }
TSaveDialog *SaveDialog1; catch (...)
TOpenDialog *OpenDialog1; {
TButton *ButtonFechar; try
void __fastcallButtonSalvarClick(TObject *Sender); {
void __fastcallButtonCarregarClick(TObject *Sender); throwException("");
void __fastcallButtonLimparClick(TObject *Sender); }
void __fastcallFormShow(TObject *Sender); catch (Exception&exception)
void __fastcallButtonFecharClick(TObject *Sender); {
private: // Userdeclarations Application->ShowException(&exception);
public: // Userdeclarations }
__fastcallTFormLog(TComponent* Owner); }
//função que imprime um cabeçalho return 0;
void __fastcallprintCabecalho(); }
}; //--------------------------------------------------------------------
//-------------------------------------------------------------------- -------
-------
extern PACKAGE TFormLog *FormLog;
//-------------------------------------------------------------------- sobre.cpp
------- //--------------------------------------------------------------------
#endif -
#include <vcl.h>
#pragmahdrstop
prjFrequencimetro.cpp
//-------------------------------------------------------------------- #include "sobre.h"
------- //--------------------------------------------------------------------
-
#include <vcl.h> #pragmaresource "*.dfm"
#pragmahdrstop TFormSobre *FormSobre;
//-------------------------------------------------------------------- //--------------------------------------------------------------------
------- -
USEFORM("frequencimetro.cpp", FormInicial); __fastcallTFormSobre::TFormSobre(TComponent*
USEFORM("sobre.cpp", FormSobre); AOwner)
USEFORM("grafico.cpp", FormGrafico); : TForm(AOwner)
USEFORM("log.cpp", FormLog); {
USEFORM("dadosEquipamento.cpp", }
FormDadosEquipamento); //--------------------------------------------------------------------
//-------------------------------------------------------------------- -
-------
WINAPI WinMain(HINSTANCE, HINSTANCE,
LPSTR, int) sobre.h
{ //--------------------------------------------------------------------
try --------
{ #ifndefsobreH
Application->Initialize(); #define sobreH
Application->CreateForm(__classid(TFormInicial), //--------------------------------------------------------------------
&FormInicial); --------
Application->CreateForm(__classid(TFormLog), #include <vcl\System.hpp>
&FormLog); #include <vcl\Windows.hpp>
Application->CreateForm(__classid(TFormGrafico), #include <vcl\SysUtils.hpp>
&FormGrafico); #include <vcl\Classes.hpp>
Application->CreateForm(__classid(TFormSobre), #include <vcl\Graphics.hpp>
&FormSobre); #include <vcl\Forms.hpp>
Application- #include <vcl\Controls.hpp>
>CreateForm(__classid(TFormDadosEquipamento), #include <vcl\StdCtrls.hpp>
&FormDadosEquipamento); #include <vcl\Buttons.hpp>
Application->Run(); #include <vcl\ExtCtrls.hpp>
}
catch (Exception&exception) //--------------------------------------------------------------------
{ --------
Paulo Garay e Marcio Couto
11
 EPD II
classTFormSobre : publicTForm
{
__published:
TPanel *Panel1;
TImage *ProgramIcon;
TLabel *Version;
TLabel *Copyright;
TLabel *Comments;
TButton *OKButton;
TLabel *Label1;
private:
public:
virtual __fastcallTFormSobre(TComponent*
AOwner);
};
//--------------------------------------------------------------------
--------
extern PACKAGE TFormSobre *FormSobre;
//--------------------------------------------------------------------
--------
#endif

Paulo Garay e Marcio Couto

12