RESUMO

Este relatório irá abordar o conhecimento referente a correção do fator de potência, um

pouco sobre potência ativa, potência reativa, potência aparente, capacitor, banco de capacitor
e como suas definições. Será apresentado também um exemplo de como deve ser feito para
se calcular qual deve ser o valor do capacitor que deve ser acoplado ao circuito e código de um
sistema desenvolvida para se calcular a correção do fator de potência.

INTRODUÇÃO

O que é potência elétrica? Potência elétrica em corrente contínua, unidade de medida de

potência. Definições referente as potências aparente, ativa e reativa. Entendendo o que será
um banco de capacitor. Exemplos de correção de fator de potência. É o que será tratado por
este trabalho. Com intuito de entender o fator de potência.

Definição de Potência Elétrica

É a capacidade que um material possui de realizar um determinado trabalho em um instante

de tempo, sendo que, ao passar por uma carga instalada em um circuito, a corrente elétrica
produz, calor, luz e movimento. Tendo então denominados de trabalho. Ao transformar a
energia elétrica, o consumidor realiza um trabalho elétrico.

Unidade de Medida da Potência Elétrica

A potência elétrica, como tal, pode ser medida. A unidade de medida da potência elétrica é o
watts, simbolizado pela letra W.

Um watt (1W) corresponde à potência desenvolvida no tempo de um segundo em uma carga,

alimentada por uma tensão de 1V, na qual circula uma corrente de 1A.

Para se determinar a potência, deve se usar a formula:

Sendo que:

 P : É a potência dissipada expressa em watts [W];

 V: É a tensão elétrica entre os terminais do consumidor expressa em volts [V];
 I: É a corrente elétrica que circula no consumidor expressa em Ampere [A].

Potência em Corrente Alternada

Quando se trata de circuitos de corrente alternada (CA) com cargas indutivas ou capacitivas,
ocorre uma defasagem entre tensão e corrente. Onde temos de considerar três tipos de
potência:

 Potência Aparente (S) ;

 Potência Ativa (P);
 Potência Reativa (Q).

Potência Aparente

É o resultado do produto da multiplicação entre a tensão e a corrente. Em circuitos não

resistivos em corrente alternada esta potência não é real, pois não considera a defasagem que
existe entre a corrente e a tensão. A mesma recebe notação S e tendo unidade de medica em
Volt Ampère (VA).

Segue uma imagem para exemplificar o que foi dito.

Potência Ativa

Potência ativa ou potência real, é a potência que realmente produz o trabalho na carga. Tem
como unidade de medida em Watts (W) e é representado pela letra P. Nos cálculos da mesma,
deve considerar o produto entre a corrente, tensão e o fator de potência (cos φ).

Potência Reativa

Potência reativa, é a porção da potência aparente que é fornecida ao circuito. Tendo como
função constituir o circuito magnético nas bobinas e um campo elétrico nos capacitores. Como
os campos aumentam e diminuem acompanhando a frequência, a potência reativa varia duas
vezes por período entre a fonte de corrente e o consumidor. A mesma, aumenta a carga dos
geradores, dos condutores e dos transformadores originando perdas de potência nesses
elementos do circuito. A unidade de medida é p Volt Ampère reativo (Var), representado pela
letra Q.

Em resumo,

1. A potência ativa é a potência que realmente realiza trabalho no sistema, como

analogia, no copo de Chopp é o Chopp descontado da espuma;
2. A potência reativa é a potência desperdiçada pelo sistema, como no copo de Chopp é
a espuma, que é desperdiçada;
3. A potência aparente é a potência total que o sistema retira da rede de alimentação, no
copo de Chopp é o valor pago pelo copo inteiro.

Fator de Potência

O fator de potência é uma relação entre potência ativa e reativa. Tendo a diferença entre o
consumo aparente e o consumo real. Ele indica uma eficiência alta e inversamente um fator de
potência baixo indica a baixa eficiência. Um baixo fator de potência indica que não está
aproveitando plenamente a energia. Para se corrigir este baixo aproveitamento, é utilizado
uma técnica conhecida como correção do fator de potência, onde é conseguida mediante a
acoplamento de banco de capacitores, com uma potência reativa contrária ao da carga,
tentando ao máximo, anular essa componente. Por exemplo, o efeito indutivo de motores
pode ser anulado com a conexão em paralelo de um capacitor junto ao equipamento.

Tendo como a principal vantagem em corrigir o fator de potência é na economia que gera na
conta de energia elétrica, além de evitar multas.

Banco de Capacitores
Como dito, anteriormente o banco de capacitores serve para corrigir o fator de potência,
tendo três tipos, sendo os bancos programáveis, os fixos e os automáticos. Cada um tem uma
determinada indicação que apenas uma empresa técnica pode informar.

O banco de capacitores programável, pode atuar em condições pré-definidas, de acordo com a

necessidade especifica. O banco de capacitores fixos, é recomendado para a correção de
cargas constantes, tais como transformadores. E o banco de capacitores automático realiza
uma compensação automática por meio de sinais de tensão e corrente ligando e desligando
módulos capacitivos de acordo com a necessidade.

Resolução do exemplo 19.5

Contudo, após entendermos um pouco sobre a teoria da correção de fator de potência, segue
o exemplo 19.5.

Um motor de 5 hp com um fator de potência atrasado 0,6 e cuja eficiência de 92 por cento
está conectado a uma fonte de 208 V e 60 HZ.

a) Estabeleça o triângulo de potência para a carga.

b) Determine o valor do capacitor que deve ser ligado em paralelo com a carga de modo
a aumentar o fator de potência para 1.
c) Determine a diferença na corrente fornecida pela fonte no circuito compensado e a
corrente no circuito não compensado.
d) Determine o circuito equivalente para o circuito acima e verifique as conclusões.
Imagem 01
Imagem 02
Imagem 03
Imagem 04
Imagem 05
Imagem 06

Conforme visto nas imagens, é demostrado como deve proceder com os cálculos para se
definir qual o valor do capacitor que deve ser acoplado ao sistema, para que se alcançar a
melhor correção do fator de potência para o sistema.

Logo, segue também imagens de uma montagem de um circuito de partida direta em um

motor. E demostrado também, os valores de potência ativa, reativa e aparente do motor.

Imagem 07, onde a mesmo mostra a configuração do motor utilizado para a partida direta.
Imagem 08, motor que será utilizado na partida direta

Imagem 09,
Imagem 10,

Imagem 11, banco de capacitores

Imagem 12, circuito

Imagem 13,
Imagem 14,

E por fim, segue também, o código fonte de um sistema desenvolvido utilizando a linguagem C
para se calcular a correção do fator de potência, de tal forma, que não se precisa fazer os
cálculos na mão, conforme demostrado anteriormente.

Primeiramente, a sistema foi montado utilizando 3 arquivos, sendo:

 Main.c;
 Funcoes.c;
 Struct.c

No arquivo Main.c, como pode ser visto logo abaixo, possui como include o arquivo funcoes.h
e dentro da função main, se chama outra função chamada Iniciar Programa.

#include "funcoes.h"

int main()

IniciarPrograma();

return 0;

}
A função chamada anteriormente esta declarada sua implementação da funcoes.c, onde nesta
mesma classe, possui diversas outras implementações de funções que serão utilizada pelo
sistema, conforme pode ser visto.

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include <unistd.h>

#include <windows.h>

#include <conio.h>

#include "funcoes.h"

#include "struct.h"

#define PI 3.14159265

float PotenciaInicial = 0.00;

float PotenciaAtiva = 0.00;

float FatorPotencia = 0.00;

float AnguloFatorPotencia = 0.00;

float Tensao = 0.00;

float FrequenciaAngular = 0.00;

float ModuloPotenciaAparente = 0.00;

float PotenciaReativa = 0.00;

float FatorPotenciaCorrecao = 0.00;

float AnguloFatorPotenciaCorrecao = 0.00;

float ValorCapacitor = 0.00;

float CorrenteNaoCompensada = 0.00;

float CorrenteCompensada = 0.00;

float CorrenteNoMotor = 0.00;

void IniciarPrograma(){

MenuPrincipal();
}

void MenuPrincipal(){

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("1- Cadastrar Cliente:\n");

printf("2- Cadastrar Equipamento:\n");

printf("3- Mostrar Dados:\n");

printf("4- Mostrar Grafico:\n");

printf("0- Fechar Sistema:\n");

int vOpt = 0;

scanf("%d",&vOpt);

switch (vOpt){

case 1:

system("cls");

CadastrarCliente();

break;

case 2:

system("cls");

CadastrarEquipamento();

break;

case 3:

system("cls");

MostrarDados();

break;

case 4:

break;

case 0:
 printf("\t\t PROGRAMA FINALIZADO\n\n");

exit(0);

break;

default:

printf("Opção Invalida!\n");

Sleep(2000);

system("cls");

MenuPrincipal();

void IniciarCalculos(){

printf("Favor tecle 1 para iniciar os calculos! \n");

int opt;

scanf("%d",&opt);

if (opt = 1){

CalculaModuloPotenciaAparente();

CalculaPotenciaReativa();

CalculaCapacitor();

CalculaCorrenteNaoCompensada();

CalculaCorrenteCompensada();

CalculaCorrenteNoMotor();

} else {

printf("Valor teclado esta invalido!");

printf("\n\n");

IniciarCalculos();

/**Métodos de Calculos**/
float CalculaFatorPotenciaAngulo(float pFatorPotencia){

float vResultadoAngulo = 0.00;

float vValor = 0.00;

vValor = 180/PI;

vResultadoAngulo = acos(pFatorPotencia)*vValor;

return vResultadoAngulo; /*Resultado onde traz o angulo do fator de potencia cosseno a

menos 1*/

void CalculaPotenciaInicial(float pPotenciaInicial){ /*Valor da potencia em HP. Ex: 5HP (746 W -

-- 1 HP) */

SetPotenciaInicial(pPotenciaInicial * 746);

void CalculaPotenciaAtiva(float pPorcentagem){

float vValor = 0;

if ((pPorcentagem > 1) && (pPorcentagem <= 100)) {

vValor = pPorcentagem / 100;

SetPotenciaAtiva(GetPotenciaInicial() / vValor);

} else if ((pPorcentagem > 0) && (pPorcentagem <= 1)){

SetPotenciaAtiva(GetPotenciaInicial() / pPorcentagem);

} else {

printf("O valor da Porcentagem esta invalida!\n\n");

exit(1);

void CalculaFrequenciaAngular(float pFrequencia){

 SetFrequenciaAngular(2*PI*pFrequencia);

void CalculaModuloPotenciaAparente(){

SetModuloPotenciaAparente(GetPotenciaAtiva()/GetFatorPotencia());

void CalculaPotenciaReativa(){

SetPotenciaReativa(GetModuloPotenciaAparente()*(sin(GetAnguloFatorPotencia()*PI/180)) );

void CalculaCapacitor(){

float vResultado = 0.00;

vResultado = (GetPotenciaAtiva()*(tan(GetAnguloFatorPotencia()*PI/180)-
tan(GetAnguloFatorPotenciaCorrecao()*PI/180)))/(GetFrequenciaAngular()*(pow(GetTensao(),
2)));

SetValorCapacitor(vResultado);

void CalculaCorrenteNaoCompensada(){

SetCorrenteNaoCompensada(GetModuloPotenciaAparente()/GetTensao());

void CalculaCorrenteCompensada(){

SetCorrenteCompensada(GetPotenciaAtiva()/GetTensao());

void CalculaCorrenteNoMotor(){

float vResultado = 0.00;

vResultado = GetPotenciaAtiva() /(GetTensao()*cos(GetAnguloFatorPotencia()*PI/180));

 SetCorrenteNoMotor(vResultado);

/**Métodos Sets**/

void SetTensao(float pTensao){

Tensao = pTensao;

void SetFatorPotencia(float pFatorPotencia){

FatorPotencia = pFatorPotencia;

void SetPotenciaInicial(float pPotenciaInicial){

PotenciaInicial = pPotenciaInicial;

void SetPotenciaAtiva(float pPotenciaAtiva){

PotenciaAtiva = pPotenciaAtiva;

void SetAnguloFatorPotencia(float pAnguloFatorPotencia){

AnguloFatorPotencia = pAnguloFatorPotencia;

void SetFrequenciaAngular(float pFrequenciaAngular){

FrequenciaAngular = pFrequenciaAngular;

void SetModuloPotenciaAparente(float pModuloPotenciaAparente){

ModuloPotenciaAparente = pModuloPotenciaAparente;
}

void SetPotenciaReativa(float pPotenciaReativa){

PotenciaReativa = pPotenciaReativa;

void SetFatorPotenciaCorrecao(float pFatorPotenciaCorrecao){

FatorPotenciaCorrecao = pFatorPotenciaCorrecao;

void SetAnguloFatorPotenciaCorrecao(float pAnguloFatorPotenciaCorrecao){

AnguloFatorPotenciaCorrecao = pAnguloFatorPotenciaCorrecao;

void SetValorCapacitor(float pValorCapacitor){

ValorCapacitor = pValorCapacitor;

void SetCorrenteNaoCompensada(float pCorrenteNaoCompensada){

CorrenteNaoCompensada = pCorrenteNaoCompensada;

void SetCorrenteCompensada(float pCorrenteCompensada){

CorrenteCompensada = pCorrenteCompensada;

void SetCorrenteNoMotor(float pCorrenteNoMotor){

CorrenteNoMotor = pCorrenteNoMotor;

/**Métodos Gets**/
float GetTensao(){

return Tensao;

float GetFatorPotencia(){

return FatorPotencia;

float GetPotenciaInicial(){

return PotenciaInicial;

float GetPotenciaAtiva(){

return PotenciaAtiva;

float GetAnguloFatorPotencia(){

return AnguloFatorPotencia;

float GetFrequenciaAngular(){

return FrequenciaAngular;

float GetModuloPotenciaAparente(){

return ModuloPotenciaAparente;

float GetPotenciaReativa(){

return PotenciaReativa;
}

float GetFatorPotenciaCorrecao(){

return FatorPotenciaCorrecao;

float GetAnguloFatorPotenciaCorrecao(){

return AnguloFatorPotenciaCorrecao;

float GetValorCapacitor(){

return ValorCapacitor;

float GetCorrenteNaoCompensada(){

return CorrenteNaoCompensada;

float GetCorrenteCompensada(){

return CorrenteCompensada;

float GetCorrenteNoMotor(){

return CorrenteNoMotor;

/*Novos Metodos*/

void MostrarDados(){

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

 printf("Visualizar qual dados?\n\n");

printf("1 - Cliente\n");

printf("2 - Equipamento\n");

int opt = 0;

scanf("%d",&opt);

switch (opt){

case 1:

DadosCliente();

break;

case 2:

DadosEquipamento();

break;

default:

printf("Opcao invalida!\n\n");

Sleep(2000);

system("cls");

MostrarDados();

break;

void DadosCliente(){

system("cls");

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("Informe o Id do cliente que deseja visualizar os dados:\n");

int vId = 0;

scanf("%d",&vId);
 char vCodigo[2];

sprintf(vCodigo,"%d",vId);

char nomeArquivo[30] = "Cliente_";

strcat(nomeArquivo,vCodigo);

strcat(nomeArquivo,".txt");

system("cls");

LerArquivo(nomeArquivo);

Sleep(2000);

printf("\n\n\n\n");

printf("Tecle 0, para voltar ao Menu Principal:\n");

int opt = 0;

scanf("%d",&opt);

if (opt == 0){

system("cls");

MenuPrincipal();

void DadosEquipamento(){

system("cls");

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("Informe o Id do cliente que deseja visualizar os dados:\n");

int vId = 0;

scanf("%d",&vId);

printf("Informe o Id do equipamento que deseja visualizar os dados:\n");

 int vId2 = 0;

scanf("%d",&vId2);

char vCodigo[2];

char vCodigo2[2];

sprintf(vCodigo,"%d",vId);

sprintf(vCodigo2,"%d",vId2);

char nomeArquivo[30] = "Equipamento_";

strcat(nomeArquivo,vCodigo);

strcat(nomeArquivo,"_Cliente_");

strcat(nomeArquivo,vCodigo2);

strcat(nomeArquivo,".txt");

system("cls");

LerArquivo(nomeArquivo);

Sleep(2000);

printf("\n\n\n\n");

printf("Tecle 0, para voltar ao Menu Principal:\n");

int opt = 0;

scanf("%d",&opt);

if (opt == 0){

system("cls");

MenuPrincipal();

void SetPotenciaMotorEquipamento(float pPotenciaMotor){

 CalculaPotenciaInicial(pPotenciaMotor);

void SetFatorPotenciaEquipamento(float pFatorPotencia){

if ((pFatorPotencia < 0) || (pFatorPotencia > 1)){

printf("O fator de potencia informado esta invalido!\n");

} else {

SetFatorPotencia(pFatorPotencia);

SetAnguloFatorPotencia(CalculaFatorPotenciaAngulo(pFatorPotencia));

void SetTensaoEquipamento(float pTensao){

if (pTensao > 0){

SetTensao(pTensao);

} else {

printf("O valor da tensao esta invalido!\n");

void SetPorcentagemEquipamento(float pPorcentagem){

CalculaPotenciaAtiva(pPorcentagem);

void SetFrequenciaEquipamento(float pFrequencia){

CalculaFrequenciaAngular(pFrequencia);

void SetFatorPotenciaCorrecaoEquipamento(float pFatorPotenciaCorrecao){

if ((pFatorPotenciaCorrecao < 0) || (pFatorPotenciaCorrecao > 1)){

printf("O fator de potencia informado esta invalido!\n");

 } else {

SetFatorPotenciaCorrecao(pFatorPotenciaCorrecao);

SetFatorPotenciaCorrecao(CalculaFatorPotenciaAngulo(pFatorPotenciaCorrecao));

É importante observar que os protótipos das funções fica no arquivo funções.h, conforme
pode ser visto.

void IniciarPrograma();

void MenuPrincipal();

void IniciarCalculos();

float CalculaFatorPotenciaAngulo(float pFatorPotencia);

void CalculaPotenciaInicial(float pPotenciaInicial);

void CalculaPotenciaAtiva(float pPorcentagem);

void CalculaFrequenciaAngular(float pFrequencia);

void CalculaModuloPotenciaAparente();

void CalculaPotenciaReativa();

void CalculaCapacitor();

void CalculaCorrenteNaoCompensada();

void CalculaCorrenteCompensada();

void CalculaCorrenteNoMotor();

void SetTensao(float pTensao);

void SetFatorPotencia(float pFatorPotencia);

void SetPotenciaInicial(float pPotenciaInicial);

void SetPotenciaAtiva(float pPotenciaAtiva);

void SetAnguloFatorPotencia(float pAnguloFatorPotencia);

void SetFrequenciaAngular(float pFrequenciaAngular);

void SetModuloPotenciaAparente(float pModuloPotenciaAparente);

void SetPotenciaReativa(float pPotenciaReativa);

void SetFatorPotenciaCorrecao(float pFatorPotenciaCorrecao);

void SetAnguloFatorPotenciaCorrecao(float pAnguloFatorPotenciaCorrecao);

void SetValorCapacitor(float pValorCapacitor);

void SetCorrenteNaoCompensada(float pCorrenteNaoCompensada);

void SetCorrenteCompensada(float pCorrenteCompensada);

void SetCorrenteNoMotor(float pCorrenteNoMotor);

float GetTensao();

float GetFatorPotencia();

float GetPotenciaInicial();

float GetPotenciaAtiva();

float GetAnguloFatorPotencia();

float GetFrequenciaAngular();

float GetModuloPotenciaAparente();

float GetPotenciaReativa();

float GetFatorPotenciaCorrecao();

float GetAnguloFatorPotenciaCorrecao();

float GetValorCapacitor();

float GetCorrenteNaoCompensada();

float GetCorrenteCompensada();

float GetCorrenteNoMotor();

void SetPotenciaMotorEquipamento(float pPotenciaMotor);

void SetFatorPotenciaEquipamento(float pFatorPotencia);

void SetTensaoEquipamento(float pTensao);

void SetPorcentagemEquipamento(float pPorcentagem);

void SetFrequenciaEquipamento(float pFrequencia);

void SetFatorPotenciaCorrecaoEquipamento(float pFatorPotenciaCorrecao);

void MostrarDados();

void DadosCliente();

void DadosEquipamento();
Será visto agora a implementação da struct.c.

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <conio.h>

#include "struct.h"

#include "funcoes.h"

#include <windows.h>

#define TAM 20

typedef struct Cliente {

char id[2];

char empresa[30];

char nomeArquivo[30];

};

typedef struct Equipamento {

char id_cliente[2];

char id[2];

char PotenciaAtiva[15];

char PotenciaReativa[15];

char PotenciaAparente[15];

char Capacitor[15];

char CorrenteCompensada[15];

char CorrenteNaoCompensada[15];

char CorrenteNoMotor[15];

char PotenciaMotorHP[15];
 char FatorPotenciaMotor[15];

char TensaoMotor[15];

char PorcentagemAproveitamento[15];

char FrequenciaMotorHZ[15];

char FatorPotenciaCorrecaoMotor[15];

char nomeArquivo[30];

};

struct Cliente c[TAM];

struct Equipamento e[TAM];

int QtdeCadastro = 0;

int QtdeCadastroEquipamento = 0;

void CadastrarCliente(){

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("\t\tCADASTRO DE CLIENTE\n\n");

printf("Informe o Nome da Empresa:\n");

char empresa[30];

gets(empresa);

gets(empresa);

char id[2];

sprintf(id,"%d",QtdeCadastro); /*converte de Inteiro para string*/

strcpy(c[QtdeCadastro].id,id); /*alimenta a variavel string*/

strcpy(c[QtdeCadastro].empresa,empresa);
 char nomeArquivo[30] = "Cliente_";

strcat(nomeArquivo,c[QtdeCadastro].id);

strcat(nomeArquivo,".txt");

strcpy(c[QtdeCadastro].nomeArquivo,nomeArquivo);

CriarArquivoTexto_char(c[QtdeCadastro].nomeArquivo,1);

QtdeCadastro = QtdeCadastro + 1;

printf("Cadastro Realizado com Sucesso!\n\n");

Sleep(2000);

system("cls");

Decisao(1);

void Decisao(int pOpt){

switch (pOpt){

case 1:

system("cls");

CadastrarClienteNovamente();

break;

case 2:

system("cls");

CadastrarEquipamentoNovamente();

break;

default:

printf("Opcao invalida!\n\n");

Sleep(2000);
 system("cls");

Decisao(pOpt);

void CadastrarClienteNovamente(){

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("\n\nDeseja Realizar um novo cadastro de cliente?\n\n");

printf("Caso SIM, tecle 1:\n");

printf("Caso NAO, tecle 2:\n");

int vOpt = 0;

scanf("%d",&vOpt);

switch (vOpt){

case 1:

system("cls");

CadastrarCliente();

break;

case 2:

system("cls");

CadastrarEquipamentoNovamente();

break;

default:

printf("Opcao invalida!\n\n");

Sleep(2000);

system("cls");

Decisao(1);

}
void CadastrarEquipamento(){

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("\t\tCADASTRO DE EQUIPAMENTO\n\n");

printf("Informe o ID do Cliente:\n");

int id_cliente = 0;

scanf("%d",&id_cliente);

sprintf(e[QtdeCadastroEquipamento].id_cliente,"%d",id_cliente);

sprintf(e[QtdeCadastroEquipamento].id,"%d",QtdeCadastroEquipamento);

sprintf(e[QtdeCadastroEquipamento].PotenciaMotorHP,"%f",InformarPotenciaMotorEquipam
ento());

sprintf(e[QtdeCadastroEquipamento].FatorPotenciaMotor,"%f",InformarFatorPotenciaEquipa
mento());

sprintf(e[QtdeCadastroEquipamento].TensaoMotor,"%f",InformarTensaoEquipamento());

sprintf(e[QtdeCadastroEquipamento].PorcentagemAproveitamento,"%f",InformarPorcentage
mAproveitamentoEquipamento());

sprintf(e[QtdeCadastroEquipamento].FrequenciaMotorHZ,"%f",InformarFrequenciaHzEquipam
ento());

sprintf(e[QtdeCadastroEquipamento].FatorPotenciaCorrecaoMotor,"%f",InformarFatorPotenci
aCorrecaoEquipamento());

/*Chama a função que realiza os calculos*/

float aux = 0;

aux = atof(e[QtdeCadastroEquipamento].PotenciaMotorHP);

SetPotenciaMotorEquipamento(aux);

aux = 0;
 aux = atof(e[QtdeCadastroEquipamento].FatorPotenciaMotor);

SetFatorPotenciaEquipamento(aux);

aux = 0;

aux = atof(e[QtdeCadastroEquipamento].TensaoMotor);

SetTensaoEquipamento(aux);

aux = 0;

aux = atof(e[QtdeCadastroEquipamento].PorcentagemAproveitamento);

SetPorcentagemEquipamento(aux);

aux = 0;

aux = atof(e[QtdeCadastroEquipamento].FrequenciaMotorHZ);

SetFrequenciaEquipamento(aux);

aux = 0;

aux = atof(e[QtdeCadastroEquipamento].FatorPotenciaCorrecaoMotor);

SetFatorPotenciaCorrecaoEquipamento(aux);

IniciarCalculos();

sprintf(e[QtdeCadastroEquipamento].PotenciaAtiva,"%f",GetPotenciaAtiva());

sprintf(e[QtdeCadastroEquipamento].PotenciaReativa,"%f",GetPotenciaReativa());

sprintf(e[QtdeCadastroEquipamento].PotenciaAparente,"%f",GetModuloPotenciaAparente());

sprintf(e[QtdeCadastroEquipamento].Capacitor,"%f",GetValorCapacitor());

sprintf(e[QtdeCadastroEquipamento].CorrenteCompensada,"%f",GetCorrenteCompensada());

sprintf(e[QtdeCadastroEquipamento].CorrenteNaoCompensada,"%f",GetCorrenteNaoCompen
sada());

sprintf(e[QtdeCadastroEquipamento].CorrenteNoMotor,"%f",GetCorrenteNoMotor());
 char nomeArquivo[30] = "Equipamento_";

strcat(nomeArquivo,e[QtdeCadastroEquipamento].id);

strcat(nomeArquivo,"_Cliente_");

strcat(nomeArquivo,e[QtdeCadastroEquipamento].id_cliente);

strcat(nomeArquivo,".txt");

strcpy(e[QtdeCadastroEquipamento].nomeArquivo,nomeArquivo);

CriarArquivoTexto_char(e[QtdeCadastroEquipamento].nomeArquivo,2);

QtdeCadastroEquipamento = QtdeCadastroEquipamento + 1;

printf("Cadastro Realizado com Sucesso!\n\n");

Sleep(2000);

system("cls");

Decisao(2);

void CadastrarEquipamentoNovamente(){

printf("\t\t BEM VINDO AO PROGRAMA!\n\n");

printf("\n\nDeseja Realizar um novo cadastro de Equipamento?\n\n");

printf("Caso SIM, tecle 1:\n");

printf("Caso NAO, tecle 2:\n");

int vOpt = 0;

scanf("%d",&vOpt);
 switch (vOpt){

case 1:

system("cls");

CadastrarEquipamento();

break;

case 2:

system("cls");

MenuPrincipal();

break;

default:

printf("Opcao invalida!\n\n");

Sleep(2000);

system("cls");

Decisao(1);

float InformarPotenciaMotorEquipamento(){

printf("Informe a Potencia do Motor em HP:\n");

float vPotenciaMotor = 0;

scanf("%f",&vPotenciaMotor);

return vPotenciaMotor;

float InformarFatorPotenciaEquipamento(){

printf("Informe o Fator de Potencia: \n");

float vFatorPotencia = 0;

scanf("%f",&vFatorPotencia);

if ((vFatorPotencia < 0) || (vFatorPotencia > 1)){

printf("O fator de potencia informado esta invalido!\n");

 InformarFatorPotenciaEquipamento();

} else {

return vFatorPotencia;

float InformarTensaoEquipamento(){

printf("Informe a Tensao: \n");

float vTensao = 0;

scanf("%f",&vTensao);

if (vTensao > 0){

return vTensao;

} else {

printf("O valor da tensao esta invalido!\n");

InformarTensaoEquipamento();

float InformarPorcentagemAproveitamentoEquipamento(){

printf("Informe a Porcentagem de Aproveitamento do Equipamento: \n");

float vPorcentagem = 0;

scanf("%f",&vPorcentagem);

return vPorcentagem;

float InformarFrequenciaHzEquipamento(){

printf("Informe a Frequencia em HZ: \n");

float vFrequencia = 0;

scanf("%f",&vFrequencia);
 return vFrequencia;

float InformarFatorPotenciaCorrecaoEquipamento(){

printf("Informe o Fator de Potencia de Correcao: \n");

float vFatorPotenciaCorrecao = 0;

scanf("%f",&vFatorPotenciaCorrecao);

if ((vFatorPotenciaCorrecao < 0) || (vFatorPotenciaCorrecao > 1)){

printf("O fator de potencia informado esta invalido!\n");

InformarFatorPotenciaCorrecaoEquipamento();

} else {

return vFatorPotenciaCorrecao;

void CriarArquivoTexto_char(char pNomeArquivo[], int pTipo){

FILE *arquivo;

arquivo = fopen (pNomeArquivo, "ab");

if (arquivo == NULL) {

printf ("Houve um erro ao abrir o arquivo.\n");

return 1;

switch (pTipo){

case 1:

fprintf(arquivo,"DADOS DO CADASTRO DO CLIENTE\n\n","");

fprintf(arquivo,"ID: %s\n",c[QtdeCadastro].id);

fprintf(arquivo,"Empresa: %s\n\n",c[QtdeCadastro].empresa);

fprintf(arquivo,"Arquivo: %s",c[QtdeCadastro].nomeArquivo);

break;

case 2:
 fprintf(arquivo,"DADOS DO CADASTRO DE EQUIPAMENTO\n\n","");

fprintf(arquivo,"ID Cliente: %s\n",e[QtdeCadastroEquipamento].id_cliente);

fprintf(arquivo,"ID Equipamento: %s\n",e[QtdeCadastroEquipamento].id);

fprintf(arquivo,"Potencia do Motor em HP:

%s\n",e[QtdeCadastroEquipamento].PotenciaMotorHP);

fprintf(arquivo,"Fator de Potencia do Motor:

%s\n",e[QtdeCadastroEquipamento].FatorPotenciaMotor);

fprintf(arquivo,"Tensao do Motor: %s\n",e[QtdeCadastroEquipamento].TensaoMotor);

fprintf(arquivo,"Porcentagem de Aproveitamento do Motor:

%s\n",e[QtdeCadastroEquipamento].PorcentagemAproveitamento);

fprintf(arquivo,"Frequencia do Motor em HZ:

%s\n",e[QtdeCadastroEquipamento].FrequenciaMotorHZ);

fprintf(arquivo,"Fator de Potencia de Correcao do Motor:

%s\n\n\n",e[QtdeCadastroEquipamento].FatorPotenciaCorrecaoMotor);

fprintf(arquivo,"RESULTADO DOS CALCULOS\n\n","");

fprintf(arquivo,"Potencia Ativa: %s\n",e[QtdeCadastroEquipamento].PotenciaAtiva);

fprintf(arquivo,"Potencia Reativa: %s\n",e[QtdeCadastroEquipamento].PotenciaReativa);

fprintf(arquivo,"Potencia Aparente:
%s\n",e[QtdeCadastroEquipamento].PotenciaAparente);

fprintf(arquivo,"Capacitor: %s\n",e[QtdeCadastroEquipamento].Capacitor);

fprintf(arquivo,"Corrente Compensada:
%s\n",e[QtdeCadastroEquipamento].CorrenteCompensada);

fprintf(arquivo,"Corrente NAO Compensada:

%s\n",e[QtdeCadastroEquipamento].CorrenteNaoCompensada);

fprintf(arquivo,"Corrente no Motor:
%s\n\n",e[QtdeCadastroEquipamento].CorrenteNoMotor);

fprintf(arquivo,"Arquivo: %s",e[QtdeCadastroEquipamento].nomeArquivo);

break;

default:

printf("Opcao Invalida!\n");

}
 fclose (arquivo);

void LerArquivo(char pNomeArquivo[]){

FILE *arquivo;

arquivo = fopen (pNomeArquivo, "r+");

if (arquivo == NULL) {

printf("Houve um erro ao abrir o arquivo.\n");

printf("Nome do arquivo esta invalido! Informe o codigo do cliente correto!\n");

return 1;

char teste[100];

while (!feof(arquivo)) {

printf("%s",fgets(teste,100,arquivo));

fclose (arquivo);

E os protótipos das implementações feita na classe anterior, fica no arquivo struct.h, conforme
será visto.

typedef struct Cliente;

typedef struct Equipamento;

void CadastrarCliente();

void Decisao(int pOpt);

void CadastrarClienteNovamente();

void CadastrarEquipamento();

float InformarPotenciaMotorEquipamento();

float InformarFatorPotenciaEquipamento();
float InformarTensaoEquipamento();

float InformarPorcentagemAproveitamentoEquipamento();

float InformarFrequenciaHzEquipamento();

float InformarFatorPotenciaCorrecaoEquipamento();

void CriarArquivoTexto_char(char pNomeArquivo[], int pTipo);

void LerArquivo(char pNomeArquivo[]);

Em resumo, da ideia inicial para o desenvolvimento deste sistema, é que deve conter um
cadastro prévio do cliente e do equipamento, onde estes dados colhidos serão salvos em
arquivo texto, onde cada cliente terá o seu próprio arquivo. E quando for preciso, seria feita a
leitura do mesmo, e mostrado na tela para o cliente visualizar os resultados. Contudo, veremos
algumas imagens da execução do sistema.

Imagem 15, tela inicial do sistema.

Imagem 16

Imagem 17
Imagem 18

Imagem 19
Imagem 20

Imagem 21
Imagem 22

Imagem 23
Imagem 24

Imagem 25, momento que o sistema é encerrado.