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
Engenharia de Processamento Digital II do Curso de
Engenharia Elétrica da Ulbra apresenta um software de
desenvolvimento de um frequencimetro digital, que através
de um supervisório faz a comunicação e aquisição de dados
através de uma interface visual orientada a objetos. O
desenvolvimento do software, monitoramento e aquisição de
dados é feito através de uma interface visual simples
orientada a objetos. O software possui duas classes que tem
características onde a classe mais complexa usa o conceito de
herança da classe menos complexa, além de permitir a
alocação de dados em memória permitindo assim a gravação
e leitura em um arquivo. Com a construção da interface
gráfica, edição do código fonte e aquisição do sinal do
gerador de funções, o software apresentou resultados
satisfatórios diante da proposta inicial do trabalho, onde o
mesmo tinha o objetivo de realizar a coleta e controle dos
dados enviados a placa.
Palavras Chaves – Monitoramento, aquisição de dados,
interface gráfica.
I. INTRODUÇÃO
A programação Orientada a objetos surgiu com o principal
objetivo de unir os dados e funções em um único
elemento: o objeto. Esta metodologia utilizada traz uma
série de vantagens sobre outras linguagens de
programação, como:
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
poderá ser manipulada. Usa-se o nível de acesso mais
restritivo, private, que faça sentido para um membro
particular. Sempre private, a menos que tenha um bom
motivo para deixá-lo com outro nível de acesso. Não se
deve permitir o acesso público aos membros, exceto em
caso de ser constantes. Isso porque membros públicos
tendem a nos ligar a uma implementação em particular e
limita a flexibilidade em mudar o código.
O Encapsulamento é dividido em dois níveis:
Nível de classe: Quando se determina o acesso de uma
classe inteira que pode ser public ou private (padrão);
Nível de membro: Quando se determina o acesso de
atributos ou métodos de uma classe que podem ser public,
private ou protectec. Para ter um método encapsulado
utiliza-se um modificador de acesso que geralmente é
public, além do tipo de retorno dele. Para se ter acesso a
algum atributo ou método que esteja encapsulado utiliza-
se o conceito de get e set. Por definição, com SET é feita
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
disposição uma coleção de classes devidamente testadas e
com um funcionamento a prova de erros, para criar novos
sistemas basta usar estas classes, sem nenhuma
necessidade de reescrever e adaptar código. Isto dá, sem
sombra de dúvida, maior rapidez e, conseqüentemente,
produtividade, produtividade no desenvolvimento de
sistemas.

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

Fig. 3. Gráfico
Pressionando o botão Gráfico (fig. 3) encontra-se um
Tchart com a sua função de mostrar a evolução da
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.
“memo log” onde é registrado os dados recebidos na
entrada do hardware (gerador de funções) para
visualização do usuário. Os dados mostrados neste memo
são salvos em um arquivo, sendo possível abrir arquivos
salvos anteriormente.

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