Departamento de Engenharia Elétrica

UNIVERSIDADE LUTERANA DO BRASIL

PRÓ-REITORIA DE GRADUAÇÃO
DEPARTAMENTO DE ENGENHARIA ELÉTRICA

Paulo Augusto Garay

Marcio Couto da Rosa

Frequencímetro

Canoas, dezembro de 2016

Departamento de Engenharia Elétrica

LISTA DE ILUSTRAÇÕES

FIGURA
1. Tela Principal 5
FIGURA 2. TELA PRINCIPAL...........................................................................5
FIGURA 3. TELA PRINCIPAL............................................................................6
FIGURA 4. EXPORTAR DADOS.........................................................................6
FIGURA 5. IMPORTAR DADOS..........................................................................6
FIGURA 7. ACIOANAMENTO BOMBA DE AQUARIO..........................................8
APÊNDICE B – FLUXOGRAMA.........................................................................25
Departamento de Engenharia Elétrica

SUMÁRIO

1. INTRODUÇÃO..........................................................................................4
2. METODOLOGIA.......................................................................................5
2.1. Software...................................................................................................................................................5
2.2. Interfaces Gráficas e Fluxogramas (UML)..............................................................................................5
2.3. Classes e Funções....................................................................................................................................7
2.4. Orçamento do projeto..............................................................................................................................7
3. MATERIAIS E MÉTODOS.........................................................................8
3.1. Descrição dos Testes Realizados no Hardware.......................................................................................8
3.2. Descrição dos Sistemas de Aquisição de Dados.....................................................................................9
4. CONSIDERAÇÕES FINAIS......................................................................10
4.1. Avaliação dos Objetivos Propostos.......................................................................................................10
4.2. Problemas Encontrados.........................................................................................................................10
4.3. Conclusões.............................................................................................................................................10
5. REFERÊNCIAS......................................................................................11
APÊNDICE A – CÓDIGO..................................................................................12
APÊNDICE B – FLUXOGRAMA.........................................................................25
Departamento de Engenharia Elétrica

1. INTRODUÇÃO

O projeto tem como objetivo desenvolver um sensor de freqüência.

O Frequencímetro é um instrumento eletrônico utilizado para medição
da freqüência de um sinal periódico. A unidade de medida utilizada é
o hertz (símbolo Hz). Este equipamento é muito utilizado em laboratórios de
eletrônica e medição em campo. O objetivo do projeto é construir um equipamento
que meça freqüências entre 1 Hz e 1k Hz.

2. METODOLOGIA

2.1. Software
O software foi desenvolvido através do programa C++ Builder, que mostrará
a tela de navegação e supervisório do Frequencímetro e utilizado a interface arduino
para a leitura da freqüência.
Departamento de Engenharia Elétrica

2.2. Interfaces Gráficas e Fluxogramas (UML)

Na tela principal do programa, conforme Figura 1 é possível visualizar a
interface do recebimento de informações onde esses dados são tratados e
convertidos em informações para os usuários.

Figura 1 – Tela Principal

O menu principal compõe de um display para visualizar a freqüência lida

pelo arduino e botões para acesso, sendo estes: botão configurar porta para
comunicação, botão conectar a porta, botão desconectar a porta, botão gráfico da
freqüência e botão log para exportar os dados adquiridos.

Figura 2 – Botão Configurar

Caso não for digitado um número será exibida uma mensagem, conforme
Figura 3.

Figura 3 – Tela Principal

Na tela exportar dados, conforme Figura 4 é possível visualizar a

quantidade de leituras realizadas através do número inserido pelo usuário.
Departamento de Engenharia Elétrica

Figura 4 – Exportar Dados

Na tela importar dados, conforme Figura 5 mostra leituras já realizadas

para visualização de dados.

Figura 5 – Importar Dados

2.3. Classes e Funções

Para o desenvolvimento do projeto foram criadas as seguintes programações
e classes.

 Nível.h – Essa classe tem como objetivo carregar os valores, realizar o

cálculo e devolver os valores para o Unit1.

 Rele.h –Classe Relé - declaração de variáveis

 Unit1.cpp - Programação Principal.

 Unit2.cpp - Programação para Exportação de Dados.

Departamento de Engenharia Elétrica

 Unit3.cpp - Programação para Importação de Dados.

 Unit4.cpp - Verifica a posição do nível e envia a informação para

programa principal ativar o relé para encher o reservatório ou
desativa a bomba.

3. MATERIAIS E MÉTODOS

Para criação desse projeto foi utilizado o software e hardware onde teve
como objetivo automatizar o processo de controle de nível de um material qualquer.
O sensor emite uma onda ultrassônica durante um determinado tempo, esta onda
sonora rebate no material e retorna ao receptor do sensor. O tempo que a onda leva
para ir e voltar são medidos pelo sensor, e como a velocidade do som é conhecida, é
possível calcular a distância do objeto através da equação:

3.1. Descrição dos Testes Realizados no Hardware

Foi realizado o teste do circuito eletrônico do acionamento da bomba
conforme figura 6, através do software será colocado em nível lógico alto o pino 11
da placa Arduino Mega 2560 onde está ligado o circuito de acionamento, com esse
pino em nível alto fará com que o relé de 5 v libere os 220 Volts para bomba onde o
mesmo começara a encher até que o pino 11 seja colocado em nível lógico baixo.
Departamento de Engenharia Elétrica

Bomba de
Aquário

Figura 6 – Acionamento da Bomba de Aquário

3.2. Descrição dos Sistemas de Aquisição de Dados

O software foi desenvolvido através do Borland C++ Builder onde será feita
a programação orientada a objetos para ter a interface visual do usuário através do
Windows. Será utilizado um sensor ultrassom HC-SR04 onde será emitido um
pulso pelo pino Trigger e recebido pelo pino Echo, esse pulsos serão enviados para a
placa Arduino MEGA 2560 e após enviados os dados pela serial. Esses dados são
tratados por 2 classes onde na Nivel.h é responsável pelo cálculo para se ter a
distância sendo que na Unit4.h / Unit4.cpp faz o controle do acionamento onde
verifica o estado que se encontra a partir dos dados enviados pelo sensor.

Para o controle do acionamento foi enviado um sinal em nível alto onde no

momento da leitura e escrita via serial é verificado na escrita se foi recebido algum
dado, caso não seja enviado nenhuma informação o pino 11 de acionamento estará
em nível lógico baixo.

Os dados recebidos pela serial são armazenados em uma matriz onde esses
dados são exportados para uma nova janela onde o software permite ao usuário
realizar o salvamento das informações adquiridas nas leituras realizadas.
Departamento de Engenharia Elétrica

4. CONSIDERAÇÕES FINAIS

4.1. Avaliação dos Objetivos Propostos

O desenvolvimento do projeto apresentou resultados satisfatórios tendo
como todos os objetivos foram alcançados para a detecção de nível. Devido à vasta
aplicação deste dispositivo de detecção sem contato pode ser utilizados em muitas
áreas de automação.

4.2. Problemas Encontrados

Para o desenvolvimento desse projeto foi encontrado uma dificuldade na
transmissão dos dados entre o microprocessador e builder, onde os dados enviados
para o software estavam com problema no tratamento das informações. Para
solução foi criado uma rotina onde os dados eram lidos e verificando a quantidade
de números enviados.
Departamento de Engenharia Elétrica

4.3. Conclusões
Neste trabalho aprendemos como desenvolver, planejar e executar o projeto
tendo como objetivo da cadeira a criação de classes, construtores, destrutores onde
agregamos conhecimento para proporcionar uma programação mais simplificada
sem repetição dos comandos e com uma compreensão mais fácil.

Para o desenvolvimento desse projeto se utilizou como alicerce a teoria, de

maneira que a partir dela poderíamos nos embasar utilizando valores típicos, a
teoria utilizada e pesquisada em C++ preparou para o desenvolvimento da interface
gráfica e do software do medidor de nível por ultrassom , me levando a conclusão de
que a linguagem C++ é muito ampla e pode ser usada para inúmeras funções.

5. REFERÊNCIAS

 Cocian, Luis Fernando Espinosa - Engenharia de processamento digital

II. Canoas : Ed. ULBRA, 2006.

 http://www.arduinoecia.com.br/2013/05/ligando-uma-lampada-com-
rele.html

 http://users.ece.utexas.edu/~valvano/Datasheets/HCSR04b.pdf


Departamento de Engenharia Elétrica 11

APÊNDICE A – CÓDIGO

I. CÓDIGO ARDUINO MEGA2560

#include <Ultrasonic.h>
#define TRIGGER_PIN 12
#define ECHO_PIN 13
int led = 11,rele;
Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN);
void setup()
{
Serial.begin(9600);
pinMode(led, OUTPUT);
}
void loop()
{
float cmMsec, inMsec;
long microsec = ultrasonic.timing();//Leitura do tempo
byte txbf[10];
sprintf((char*)txbf,"%06d",microsec);//Converte para formato 6 digitos
Serial.write(txbf,6);

if(Serial.available())
{//Verifica se chegou algum byte
char Valor = Serial.read();//Lê o valor que foi enviado
if(Valor == '1')
{
digitalWrite(led, HIGH);
}
else
{
digitalWrite(led, LOW);

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 12

}
}
delay(1000);
}
II. NIVEL.H

#ifndef NivelH
#define NivelH
#include <math.h>
#include <iostream.h>
//------------------------------------------------------------------------------
class Nivel{
private:
public:
float v;
float k;
float d;
void Nivel::fCalculaVelocidade(int Temperatura, double Velocidade);
void Nivel::fCalculaAltura(double);

};
//------------------------------------------------------------------------------
void Nivel::fCalculaVelocidade(int Temperatura, double Velocidade)
{
k=pow(Velocidade,2)/(Temperatura+273);
v=sqrt(k*(Temperatura+273));
}
//------------------------------------------------------------------------------
void Nivel::fCalculaAltura(double tempo)
{
d=(29.7-((tempo*v/20000)));
}
//------------------------------------------------------------------------------
#endif

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 13

III. RELE.H

#ifndef ReleH
#define ReleH
//---------------------------------------------------------------------------
class Rele{
private:
bool estado // estado do rele
public:
Rele(int); // metodo construtor
void Ligar(void); // liga o rele
void Desligar(void); // desliga o rele
bool Ligado(void); // verifica o estado do rele
bool Desligado(void); // verifica o estado do rele
~Rele(void); // metodo destrutor
};
//---------------------------------------------------------------------------
#endif

IV. UNIT1.CPP

#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
#include "Nivel.h"
#include "Rele.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CPort"
#pragma link "CPortCtl"

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 14

#pragma resource "*.dfm"

int T,V,i=0,tempo=0,Dados[5][1000],m,b;
double k;
Nivel h;
Rele *rele1= new Rele(1);
TForm1 *Form1;
TForm2 *Form2;
TForm3 *Form3;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
Label1->Caption="Temperatura Ambiente";
Label2->Caption="Velocidade do ar";
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{
ComPort1->ShowSetupDialog();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
AnsiString Str, Valor,led=0;
int inf = 7;
int med = 15;
int interm = 20;
int sup = 25;
int res;
Memo1->Clear();
Series2->Clear();
Form2->Dados->Refresh();
if (Button2->Caption=="Desconectar")
{
Button2->Caption="Conectar";
ComPort1->Close();

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 15

}
else
{
if (!ComPort1->Connected)
{
ComPort1->Open();
try
{
Valor=InputBox("Amostras","Numeros de Leituras","");
Edit6->Text=AnsiString(Valor);
m=StrToInt(Valor);
Button2->Caption="Desconectar";
i=0;
while(Button2->Caption=="Desconectar")
{
if( Edit6->Text>i || Edit6->Text=="")
{
for (m;m>i; i++)
{
while(ComPort1->InputCount()<6)
{
Application->ProcessMessages();
}
ComPort1->ReadStr(Str,6);
Edit3->Text=Str;
res=StrToInt(Label11->Caption);
if(res>sup)// se ultrapassou o superior, desliga a bomba
{
rele1->Desligar();
}
if(res<inf) // se ultrapassou o inferior, liga a bomba
{
rele1->Ligar();
}
if(rele1->Ligado())
{
ComPort1->WriteStr('1');

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 16

Application->ProcessMessages();
}
else
{
ComPort1->WriteStr('0');
Application->ProcessMessages();
}
if(res>interm) // mostra imagem no nivel alto
{
Image1->Visible=false;
Image3->Visible=false;
Image4->Visible=true;
}
if(res<inf) // mostra imagem no nivel baixo
{
Image1->Visible=true;
Image3->Visible=false;
Image4->Visible=false;
}
if(res==med) // mostra imagem no nivel intermediario
{
Image1->Visible=false;
Image3->Visible=true;
Image4->Visible=false;
}
Memo1->Lines->Add(Str);
Edit3->Text ="";
}
}
else
{
rele1->Desligar(); // desliga a bomba
ShowMessage("Leituras Realizadas");
Button2->Caption="Conectar";
ComPort1->Close();
}
}

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 17

}
catch (Exception & e)
{
ShowMessage("Insira o numero de leitura a serem feitas");
ComPort1->Close();
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ComPort1RxChar(TObject *Sender, int Count)
{

AnsiString Str;
ComPort1->ReadStr(Str, Count);
Edit3->Text =Str;
Memo1->Text = Memo1->Text +Str;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit1Change(TObject *Sender)
{
T=Edit1->Text.ToDouble();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Edit2Change(TObject *Sender)

{
V=Edit2->Text.ToDouble();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit3Change(TObject *Sender)
{
if(Edit3->Text !="")
{
int tt;
double vv,strr ;
tt=Edit1->Text.ToInt();

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 18

vv=Edit2->Text.ToDouble();
h.fCalculaVelocidade(tt,vv);
strr=StrToFloat(Edit3->Text);
Edit4->Text = h.v;
h.fCalculaAltura(strr);
Dados[0][i]=i;
Dados[1][i]=h.v;
Dados[2][i]=tt;
Dados[3][i]=h.k;
Dados[4][i]=h.d;
AnsiString AS;
Label3->Caption = AS.sprintf("%3.1f",h.d);
Label11->Caption= AS.sprintf("%3.0f",h.d);
Series2->AddY(atof(Form1->Label3->Caption.c_str()),"",clHotLight);
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Configurar1Click(TObject *Sender)
{
ComPort1->ShowSetupDialog();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
ComPort1->Close();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Importar1Click(TObject *Sender)

{
Form3->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Exportar1Click(TObject *Sender)
{
Form2->Show();
Application->ProcessMessages();

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 19

if(Button2->Caption=="Conectar")
{
Application->ProcessMessages();
for(b=0;b<=i;b++)
{
Form2->Dados->Cells[0][b+1]= Dados[0][b];
Form2->Dados->Cells[1][b+1]= Dados[1][b];
Form2->Dados->Cells[2][b+1]= Dados[2][b];
Form2->Dados->Cells[3][b+1]= Dados[3][b];
Form2->Dados->Cells[4][b+1]= Dados[4][b];
Form2->Dados->RowCount = b+1;
}
}
else
{
ShowMessage("Leituras não Finalizadas");
Form2->Close();
}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

{
rele1->Ligar();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Sair1Click(TObject *Sender)

{
Form1->Close();
Form2->Close();
Form3->Close();
}
//---------------------------------------------------------------------------

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 20

V. UNIT2.CPP

//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#pragma hdrstop
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{
Dados->Cells[0][0]="Leitura";
Dados->Cells[1][0]="Velocidade";
Dados->Cells[2][0]="Temperatura";
Dados->Cells[3][0]="Constante";
Dados->Cells[4][0]="Distância";
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button2Click(TObject *Sender)
{
int l=0;
FILE *ArqNovo=NULL;
SaveDialog1->Execute();
ArqNovo = fopen(SaveDialog1->FileName.c_str(),"w");

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 21

if(ArqNovo==NULL)
cout<<"Erro ao abrir o arquivo para gravação \n";

else
{
for(l=0;l<1;l++)
{
fprintf(ArqNovo,"%s\t%s\t%s\t%s\t%s\n",Dados->Cells[0]
[0],Dados->Cells[1][0],Dados->Cells[2][0],Dados->Cells[3][0],Dados->Cells[4]
[0]);
for(int a = 1; a <Dados->RowCount;a++)
{
fprintf(ArqNovo,"%s\t\t%s\t\t%s\t\t%s\t\t%s\n",Dados-
>Cells[0][a],Dados->Cells[1][a],Dados->Cells[2][a],Dados->Cells[3][a],Dados-
>Cells[4][a]);
}
fclose(ArqNovo);
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button1Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button4Click(TObject *Sender)
{
for(int a = 0; a <Dados->RowCount;a++)
{
Dados->Cells[0][a]="";
Dados->Cells[1][a]="";
Dados->Cells[2][a]="";
Dados->Cells[3][a]="";
Dados->Cells[4][a]="";

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 22

}
}
//---------------------------------------------------------------------------

VI. UNIT3.CPP

//---------------------------------------------------------------------------
#include <vcl.h>
#include <stdio.h>
#pragma hdrstop
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm3 *Form3;
//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner)
{
Memo1->Clear();
}
//---------------------------------------------------------------------------
void __fastcall TForm3::Button1Click(TObject *Sender)
{
FILE *ArqNovo;
OpenDialog1->Execute();
ArqNovo = fopen(OpenDialog1->FileName.c_str(),"r");
Memo1->Lines->LoadFromFile(OpenDialog1->FileName.c_str());
fclose(ArqNovo);
}
//---------------------------------------------------------------------------
void __fastcall TForm3::Button2Click(TObject *Sender)
{
Memo1->Clear();
}
//---------------------------------------------------------------------------

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 23

void __fastcall TForm3::FecharClick(TObject *Sender)

{
Close();
}
//---------------------------------------------------------------------------

VII. UNIT4.CPP

#include<Rele.h>
//------------------------------------------------------------------------------
Rele::Rele(int nruRele) // metodo construtor
{
Desligar(); // Sempre inicia o rele desligado
}
//------------------------------------------------------------------------------
void Rele::Ligar(void) // liga o rele
{
estado = true;
}
//------------------------------------------------------------------------------
void Rele::Desligar(void) // desliga o rele
{
estado = false;
}
//------------------------------------------------------------------------------
bool Rele::Ligado(void) // verifica se o estado do rele e ligado
{
return (estado ? true : false); // retorna true se ligado e false se desligado
}
//------------------------------------------------------------------------------
bool Rele::Desligado(void) // verifica se o estado do rele e desligado
{
return (estado ? false : true); // retorna true se desligado e false se ligado
}
//------------------------------------------------------------------------------
Rele::~Rele(void) // metodo destrutor
{

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 24

Desligar(); // Sempre finaliza o rele desligado

}

APÊNDICE B – FLUXOGRAMA

Não

Início
Leituras
de Dados Leituras
Realizadas

Conectar
Sim
Verifica
Não
Nível
Baixo Não
Visualizar
Inserir Dados
leituras Sim
Sim
Aciona Bomba
D'Água

Não
Leituras > 0 Abrir Salvar
Dados Dados
Não

Sim Sim Sim

Importar Exportar Dados

Arquivo "Arquivo.txt"

Figura 8 – Fluxograma

– Revisão A
Universidade Luterana do Brasil
Departamento de Engenharia Elétrica 25

– Revisão A
Universidade Luterana do Brasil