Monografia-2019 VFINAL

UNIVERSIDADE SANTA CECÍLIA
FACULDADE DE ENGENHARIA
CURSO DE ENGENHARIA ELÉTRICA
DOUGLAS SILVA CRUZ
FELIPE PEREIRA MUNIZ SILVA
INGRID ARRUDA RAMIL DOS SANTOS
MATHEUS RICHARDSON DOS SANTOS ANTUNES
PEDRO HENRIQUE ALMEIDA MERLIN
APLICATIVO MOBILE PARA CÁLCULO DE

FLUXO DE POTÊNCIA
Santos – SP
2019
2
UNIVERSIDADE SANTA CECÍLIA

FACULDADE DE ENGENHARIA
CURSO DE ENGENHARIA ELÉTRICA
DOUGLAS SILVA CRUZ
APLICATIVO MOBILE PARA CÁLCULO DE

FLUXO DE POTÊNCIA
Trabalho de Conclusão de Curso

Apresentado à Faculdade Universidade
Santa Cecília, como requisito parcial para
obtenção do título de graduação em
Engenharia Elétrica.
Santos - SP
2019
3
DOUGLAS SILVA CRUZ
APLICATIVO MOBILE PARA CÁLCULO DE FLUXO DE POTÊNCIA
Trabalho de Conclusão de Curso apresentado como exigência parcial para

obtenção do título de graduação de Engenheiro Eletricista à Comissão Julgadora da
Universidade Santa Cecília.
Data da Aprovação: 07/12/2019.
Banca Examinadora
___________________________________________________________________
Prof. Msc Alexandre Shozo Onuki
__________________________________________________________________
Engenheiro David Almeida
___________________________________________________________________
Engenheiro Msc. José de Melo Camargo
__________________________________________________________________
Prof. Engenheiro Sérgio Schina de Andrade
4
DEDICATÓRIA
Dedicamos este trabalho de conclusão de curso à todos que nos apoiaram e

impulsionaram para que continuássemos dando nosso melhor e não desistíssemos
dos nossos sonhos: a Deus, aos nossos Pais, familiares, professores e
companheiros.
5
AGRADECIMENTOS
Agradecemos a Deus por esta grande realização de estar concluindo o curso de

Graduação em Engenharia Elétrica.
Também aos Mentores que nos proporcionaram grandes momentos de aprendizado,

nos incentivando a sermos cada vez melhores, e, por tabela, profissionais mais
qualificados.
E aos nossos Pais por terem nos dado todo apoio e força necessários para
alcançarmos nossos objetivos.
6
EPÍGRAFE
“Nossas virtudes e nossos defeitos são inseparáveis, assim como a força e a

matéria. Quando separados, o homem deixa de existir.”
(Nikola Tesla)
7
RESUMO
No presente trabalho é apresentado o desenvolvimento de um aplicativo

didático (a ser utilizado em aulas de Sistemas de Potência II do curso de Engenharia
Elétrica da Universidade Santa Cecília) para realização do cálculo de fluxo de potência
em uma rede determinada e configurada pelo usuário. Para que fosse possível iniciar
a elaboração deste projeto, foi determinada a linguagem de programação que
pudesse ser utilizada em várias plataformas e o método matemático que basearia o
algoritmo. Desta forma, o projeto foi desenvolvido em HTML e JavaScript, que são
linguagens de simples aprendizagem e que podem ser compiladas para aplicação de
diversas plataformas por meio do Phonegap. Estando determinadas as linguagens de
programação, desenvolveu-se um algoritmo para teste de consistência dos cálculos.
Após verificar a capacidade do algoritmo de realizar cálculos com apenas duas barras,
foram realizadas as alterações no código para as funções de inserção de múltiplos
componentes (barras e linhas) para então realizar o cálculo de uma rede. Para a
avaliação do aplicativo desenvolvido, foi realizado uma análise comparativa dos
resultados do mesmo com o software ANAREDE em diversas configurações de rede.
Então, estando o aplicativo finalizado foi desenvolvida uma Interface Homem Máquina
(IHM) para representar todo o sistema de forma mais amigável para o usuário exibindo
os dados e resultados em telas gráficas e tabelas respectivamente.
Palavras-chaves: Fluxo de Potência; Sistemas de Potência II; Cálculo de Fluxo de

Potência; Aplicativo.
8
ABSTRACT
This academic work presents the development of a didactic application to do the

power flow calculation in a network, determined and configured by the user. In order
to be able to start the elaboration of this project, it was determined the programming
language that could be used in various platforms and the mathematical method that
would base the algorithm. So, the project was developed in HTML and JavaScript,
which are simple learning languages and can be compiled for various platforms by
Phonegap. Once the programming languages were determined, an algorithm for
testing the consistency of calculating was developed. After verifying the ability of the
algorithm to perform calculations with only two bars, changes were made to the code,
adding the capability of insert multiple components (bars and lines) to perform the
calculation of a network. The accuracy of the algorithm for multi-bar network
calculations was verified by comparing the results of the application against the
ANAREDE software in various network configurations. So, being the algorithm applied
and tested, a Human Machine Interface (HMI) was developed to show the whole
system in an user friendly way, displaying the data and results in graphical screens
and tables respectively.
Keywords: Power flow; Power Systems II; Power flow calculation; Application.
9
LISTA DE FIGURAS
Figura 1 - Exemplo de rede com 2 barras, uma linha, 2 Capacitores shunt.............................22

Figura 2 - Convenção do sentido de fluxo de potência (Fonte: MONTICELLI, Alcir, 2003) ....24
Figura 3 - Método de Newton Raphson (Fonte: MONTICELLI, Alcir, 2003; p.217) .................26
Figura 4 - Rede de duas barras ....................................................................................................30
Figura 5 - Fluxograma básico do cálculo de fluxo de potência ..................................................39
Figura 6 - Painel de inserção de dados ........................................................................................42
Figura 7 - Exibição do valor da incógnita .....................................................................................46
Figura 8 - Dados do exemplo inseridos na base .........................................................................49
Figura 9 - Resultado do cálculo de teste......................................................................................49
Figura 10 - Fluxograma detalhado do aplicativo .........................................................................77
Figura 11 - Código fonte da tela Inicial.........................................................................................79
Figura 12 - Tela Inicial do aplicativo sem a programação do CSS............................................80
Figura 13 - Código fonte da tela Lista de Componentes ............................................................81
Figura 14 - Código fonte da tela Lista de Componentes ............................................................81
Figura 15 - Tela Lista de Componentes sem o CSS ..................................................................82
Figura 16 - Código fonte tela Add Componentes ........................................................................84
Figura 20 - Tela Add Componentes para barra ...........................................................................85
Figura 21 - Tela Add Componentes para LT ...............................................................................85
Figura 22 - Código fonte da tela Configurações..........................................................................86
Figura 23 - Código fonte da tela Configurações..........................................................................86
Figura 24 - Tela Configurações ....................................................................................................87
Figura 25 - Código fonte tela Resultados ....................................................................................88
Figura 26 - Tela Inicial do aplicativo com CSS ............................................................................88
Figura 27 - Tela Lista de Componentes com CSS ......................................................................89
Figura 28 - Tela Lista de Componentes com CSS e sub menu .................................................89
Figura 29 - Tela Add Componentes com CSS e menu flutuante ...............................................90
Figura 30 – Tela Add Componentes com CSS para barra Vθ ...................................................91
Figura 31 – Tela Add Componentes com CSS para barra PV...................................................91
Figura 32 – Tela Add Componentes com CSS para barra PQ ..................................................91
Figura 33 – Tela Add Componentes com CSS para LT .............................................................91
Figura 34 – Tela Configurações com CSS ..................................................................................92
Figura 35 - Tela Resultados com CSS e aba de fluxos ..............................................................93
Figura 36 – Tela Resultados com CSS e aba de tensões .........................................................93
10
LISTA DE TABELAS
Tabela 1 - Dados da rede de 2 barras .........................................................................................30

Tabela 2 - Dados de impedância da linha em p.u.......................................................................30
Tabela 3 – Parâmetros de rede do sistema elétrico de 3 barras ...............................................63
Tabela 4 – Dados de impedância (em p.u.) das linhas do sistema elétrico com 3 barras ......63
Tabela 5 - Valores das incógnitas calculados, assim como seus erros percentuais, no Power
Flow e no ANAREDE para o sistema elétrico de 3 barras .........................................................63
Tabela 6 – Fluxos e perdas calculados (em p.u.) pelo ANAREDE e pelo Power Flow para o
sistema elétrico de 3 barras e os erros percentuais entre os dois programas .........................64
Tabela 7 - Parâmetros de rede do sistema elétrico de 5 barras ................................................65
Tabela 8 - Dados de impedância (em p.u.) das linhas do sistema elétrico com 5 barras .......65
Tabela 9 - Valores das incógnitas encontrados no Power Flow e no ANAREDE, assim como
os erros percentuais, para o sistema elétrico de 5 barras..........................................................65
Tabela 10 - Fluxos calculados (em p.u.) pelo ANAREDE e pelo Power Flow para o sistema
elétrico de 5 barras e os erros percentuais entre os dois programas .......................................66
Tabela 11 - Parâmetros de rede do sistema elétrico de 9 barras ..............................................67
Tabela 12 - Dados de impedância (em p.u.) das linhas do sistema elétrico com 9 barras .....67
Tabela 13 - Valores dos ângulos de defasagem calculados no Power Flow e no ANAREDE,
assim como os erros percentuais, para o sistema elétrico de 9 barras ....................................68
Tabela 14 - Valores das tensões (em p.u.) calculadas no Power Flow e no ANAREDE, assim
como os respectivos erros percentuais, para o sistema elétrico de 9 barras ...........................68
elétrico de 9 barras e os erros percentuais entre os dois programas .......................................69
Tabela 16 - Parâmetros de rede do sistema elétrico de 14 barras ...........................................70
Tabela 17 - Dados de impedância (em p.u.) das linhas do sistema elétrico com 14 barras ...70
Tabela 18 - Valores dos ângulos de defasagem calculados no Power Flow e no ANAREDE,
assim como os erros percentuais, para o sistema elétrico de 14 barras ..................................71
Tabela 19 - Valores das tensões (em p.u.) calculadas no Power Flow e no ANAREDE, assim
como os respectivos erros percentuais, para o sistema elétrico de 14 barras .........................72
elétrico de 14 barras e os erros entre os dois programas ..........................................................72
Tabela 21 - Teste de performance ...............................................................................................94
11
Sumário
CAPÍTULO 01 – INTRODUÇÃO ...................................................................................................14
1.1 Considerações Iniciais....................................................................................................14
1.2 Objetivo ............................................................................................................................15
1.3 Metodologia .....................................................................................................................15
1.4 Estado da Arte.................................................................................................................17
1.5 Organização do Trabalho ...............................................................................................18
CAPÍTULO 02 - FUNDAMENTAÇÃO TEÓRICA PARA O CÁLCULO DE FLUXO DE
POTÊNCIA......................................................................................................................................20
2.1 Introdução ao Fluxo de Potência ...................................................................................20
2.2 Parâmetros de Rede e Fundamentos do “Estudo Estático”........................................21
2.3 Definição do Tipo das Barras.........................................................................................23
2.4 Convenção do Sentido do Fluxo ...................................................................................24
2.5 Solução das Equações de Fluxo de Potência pelo Método de Newton-Raphson ....24
2.6 Exemplo para Referência ...............................................................................................30
2.6.1 Determinação das Matrizes de Condutância e Susceptância. ...............................31
2.6.2 Cálculos Referentes a Primeira Iteração. .................................................................31
2.6.3 Cálculos Referentes a Segunda Iteração .................................................................33
2.6.4 Cálculos Referentes a Terceira Iteração ..................................................................35
2.7 Conclusões Parciais .......................................................................................................35
CAPÍTULO 03 – ESTRUTURAÇÃO E IMPLANTAÇÃO DO APLICATIVO PARA CÁLCULO
DO FLUXO DE POTÊNCIA...........................................................................................................37
3.1 Definição da Plataforma para Implantação do Conjunto de Algoritmos para o
Cálculo de Fluxo de Potência....................................................................................................37
3.2 Implementação do Conjunto de Algoritmos para o Cálculo do Fluxo de Potência ...39
3.2.1 Determinação do Fluxograma do Processo do Cálculo de Fluxo de Potência .....39
3.2.2 Desenvolvimento dos Códigos Utilizados para o Cálculo de Fluxo de Potência
Envolvendo Duas Barras ..........................................................................................................40
3.2.3 Testes Preliminares para Avaliação do Conjunto de Algoritmos para Cálculo do
Fluxo de Potência......................................................................................................................48
3.3 Desenvolvimento dos Códigos Utilizados para o Cálculo de Fluxo de Potência
Envolvendo Múltiplas Barras .....................................................................................................49
3.4 Conclusões parciais........................................................................................................61
CAPÍTULO 4 – AVALIAÇÃO DA PRECISÃO DO CONJUNTO DE ALGORITMOS PARA
CÁLCULO DO FLUXO DE POTÊNCIA .......................................................................................62
4.1 Metodologia Utilizada nos Testes da Avaliação do Sistema ......................................62
12
4.2 Descrição dos Testes da Avaliação do Sistema ..........................................................62

4.2.1 Resultados do Teste com Sistema Elétrico com 3 Barras ......................................62
4.2.4 Resultados do Teste com Sistema Elétrico com 14 Barras ....................................70
4.3 Conclusões Parciais do Capítulo ...................................................................................74
CAPÍTULO 5 – DESENVOLVIMENTO DA IHM DO APLICATIVO............................................75
5.1 Levantamento das Necessidades Básicas do Usuário ...............................................75
5.2 Definição da Plataforma para o Desenvolvimento da IHM .........................................75
5.3 Definições Iniciais para o Desenvolvimento da IHM ....................................................76
5.4 Desenvolvimento da Interface Homem Máquina .........................................................78
5.4.1 Desenvolvimento da Tela “Inicial” .............................................................................78
5.4.2 Desenvolvimento da Tela “Lista de Componentes” .................................................80
5.4.3 Desenvolvimento da Tela “Add Componentes”........................................................82
5.4.4 Desenvolvimento Da Tela “Configurações” ..............................................................85
5.4.5 Desenvolvimento da Tela “Resultados” ....................................................................87
5.5 Versões Finais das Telas ...............................................................................................88
5.5.1 Versão Final da Tela “Inicial” .....................................................................................88
5.5.2 Versão Final da Tela “Lista de Componentes” .........................................................89
5.5.3 Versão Final da Tela “Add Componentes” ...............................................................89
5.5.4 Versão Final da Tela “Configurações” ......................................................................92
5.5.5 Versão Final da Tela “Resultados” ............................................................................92
5.6 Testes Finais do Aplicativo ............................................................................................93
5.6.1 Teste de Performance do Aplicativo .........................................................................93
5.6.2 Teste de Performance da IHM ...................................................................................94
5.7 Conclusões Parciais .......................................................................................................95
CAPÍTULO 6 – CONCLUSÕES ....................................................................................................96
6.1 Conclusões Finais...........................................................................................................96
6.2 Propostas para Trabalhos Futuros ................................................................................97
REFERÊNCIAS ..............................................................................................................................98
APÊNDICE I – CÓDIGO FONTE DA TELA “INICIAL” ..............................................................100
APÊNDICE II – CÓDIGO FONTE DA TELA “LISTA DE COMPONENTES” ..........................102
APÊNDICE III – CÓDIGO FONTE DA TELA “ADD COMPONENTES” ..................................106
APÊNDICE IV – CÓDIGO FONTE DA TELA “CONFIGURAÇÕES” .......................................114
13
APÊNDICE V – CÓDIGO FONTE DA TELA “RESULTADOS” ................................................116

APÊNDICE VI – CÓDIGO FONTE DA TELA “EDITAR COMPONENTES”............................118
14
CAPÍTULO 01 – INTRODUÇÃO
Neste capítulo são apresentadas as considerações iniciais que motivaram o
desenvolvimento deste tema, assim como o objetivo final e a metodologia utilizada
para alcançar o mesmo. Além do levantamento do estado da arte e, por fim, o escopo
das divisões dos capítulos deste trabalho.
1.1 Considerações Iniciais

Atualmente, os aplicativos são cada vez mais utilizados para fins educacionais,
trazendo mais dinamicidade, facilidade e interesse dos alunos, pois, de acordo com
Soad (2017), a comunidade científica tem estudado assuntos pertinentes ao ensino e
observado que aplicações computacionais vêm apresentando uma importância cada
vez maior nos ramos acadêmicos, assim como no meio industrial. Tais ferramentas
virtuais e dinâmicas permitem uma visualização mais prática e fácil de conteúdos
ministrados em meios estáticos, tornando-se fundamentais para aprimorar a
aprendizagem.
Além de facilitarem a eficiência da compreensão dos aprendizes, também

auxiliaram mentores a conquistarem melhor a atenção destes, sendo isto uma
dificuldade encontrada pelos professores nascidos nas gerações X e Y que lecionam
para a atual, Z. Sendo que esta, já nasce envolvida com tecnologia, devido ao rápido
contato com videogames e computadores, interferindo nas características dos novos
estudantes e futuros profissionais (KNITTEL, Tânia Filomena, 2014). E, por conta do
excesso de informações expostas em todos os lugares desde o início da vida (como
em televisões, standarts virtuais de publicidade, aparelhos móveis – como
smartphones e tablets, games, aplicativos de pesquisa, blogs e vários outros meios),
tornou-se muito comum a realização de várias tarefas simultaneamente, com isso, o
perfil “multitarefa” passou a ser usual. Portanto, seguir metodologias monótonas de
ensino não é mais eficaz para atingir os estudantes desta nova era, sendo necessário
possuir criatividade e ferramentas diversas para expor, explicar e demonstrar o que
deseja ser transmitido.
E, devido à facilidade em acessar aplicativos mobiles, tornaram-se ferramentas

ainda mais interessantes e eficientes. Pois tornam mais produtivo o curto espaço de
15
tempo livre, aproveitando os momentos gastos com deslocamento, por exemplo

(SOAD, Gustavo Willians, 2017).
Por fim, levando-se em conta as abordagens citadas, pode-se concluir que

estes novos perfis comportamentais agregaram grandes avanços no mercado
industrial. Pois com a facilidade de acesso às informações, a dinamicidade de ideias,
as funções “multitarefas”, criatividade e entre outras características, geraram e ainda
geram criações inovadoras em um ritmo exponencial, tornando os processos mais
automatizados, seguros e digitais. E tais melhorias tendem a se aprimorarem cada
vez mais com a atualização e informatização dos meios de ensino.
1.2 Objetivo
Este trabalho tem como objetivo o desenvolvimento de um aplicativo gratuito e
de fácil acesso para que os estudantes de engenharia elétrica possam realizar
simulações de problemas envolvendo fluxos de potência, apresentando as variações
e proporções relacionadas às mudanças da topologia da rede e dos dados
operacionais de forma dinâmica e eficaz.
A fim de que este aplicativo seja de fácil uso, ele será para multiplataformas
mobiles (framework), a fim de fornecer disponibilidade para todo o público alvo
(estudantes com diversos sistemas operacionais nos smartphones).
Por fim, o programa tem como propósito trazer mais uma ferramenta de ensino
para as aulas de Sistemas de Potência II do curso de Engenharia Elétrica da
Universidade Santa Cecília, otimizando o tempo hábil para ministrá-las, pois os
cálculos e demonstrações poderão ser finalizados em segundos.
1.3 Metodologia
Com o intuito de atingir de forma satisfatória o objetivo estabelecido por este
trabalho, foi elaborado um planejamento de atividades sequenciais, sendo pautado
pelo roteiro a seguir:
16
a) Identificação das necessidades básicas do aplicativo
Foi realizado um levantamento das necessidades de aprendizagem dos alunos

(por meio de entrevista com o professor que ministra a matéria de Sistemas de
Potência II), também foi verificado a relação de dados necessários para compreensão
do sistema e dos fluxos de potência existentes no mesmo.
b) Avaliação da metodologia de estudo estático para fluxo de potência de

uma rede
Nesta etapa foram estudadas as equações que regem o sistema de fluxo de

potências (ativas e reativas) em uma rede radial ou em malha, bem como o método
matemático matricial para análise do sistema Newton Raphson, desenvolvido pelos
matemáticos Isaac Newton e Joseph Raphson.
c) Identificação da tecnologia para elaboração da programação e software
Estudo das tecnologias e protocolos de programação que possibilitam

realização de cálculos matemáticos matriciais, com derivadas parciais, bem como a
apresentação gráfica das barras e fluxos, onde estes sejam apresentados em
sistemas tanto Android quanto iOS.
d) Desenvolvimento do algoritmo
Nesta parte do trabalho foi elaborado o fluxograma orientativo para realização

dos processos lógicos e matemáticos necessários para o cálculo de fluxo de potência.
A partir do mesmo foi implementado o conjunto de algoritmos inicial para o teste da
lógica e também da matemática em plataforma computacional, utilizando uma
interface gráfica simples. Após a constatação da consistência do conjunto de
algoritmos responsável pelos cálculos, foi elaborado o código principal utilizando
linguagem de programação de fácil aplicação a plataforma Android.
17
e) Implantação e testes do algoritmo
Após o desenvolvimento do algoritmo através de linguagem de programação

para um computador, foi gerado o instalador para o sistema operacional Android,
possibilitando simular diversos modelos de redes, afim de verificar o comportamento
deste em plataforma mobile, bem como sua assertividade dos resultados e seus
limites operacionais.
Para validar a confiabilidade do aplicativo desenvolvido, foi realizado um

comparativo com um programa consolidado na estimativa de fluxo de potência em
regime permanente no Brasil, vale destacar que, para tal análise foram realizados
testes com redes de até 14 barras.
f) Desenvolvimento da IHM
Com o aplicativo estando funcional, foi desenvolvido o sistema de apresentação

gráfica, de forma que o usuário selecione a quantidade de barras, a topologia da rede
e os parâmetros inicialmente inseridos (impedâncias e potências) e então com apenas
um comando, as demais variáveis serão calculadas e apresentadas em forma de
tabela, afim de facilitar a visualização e compreensão do usuário.
1.4 Estado da Arte

Atualmente existem diversos softwares que simulam fluxo de potência, seja
para fins comerciais ou acadêmicos. O ANAREDE pode ser considerado a principal
ferramenta comercial para análise de sistemas de potência no Brasil (sendo utilizado
pelo ONS), vale destacar que o mesmo possui uma versão acadêmica disponível
apenas para universidades e reduzida a pequenas redes elétricas. Também podem
ser citados FLUPOT e Power World como simuladores que se destacam nessa área.
Na área acadêmica, foram desenvolvidos programas computacionais para

cálculo de fluxo de potência que serão listados a seguir:
18
A tese de mestrado intitulada “Um Programa Interativo para Estudos de Fluxo

de Potência” (Canossa, 2007) teve como objetivo desenvolver um software de
simulação de fluxo de potência. Este trabalho foi feito em ambiente MATLAB com uma
interface gráfica desenvolvida no próprio programa para entrada de dados e obtenção
dos resultados, com a finalidade de facilitar o manuseio pelo usuário, já que a ideia é
que seja uma ferramenta de uso didático e que auxilie as aulas de sistemas de
potência. O mesmo utiliza o método de Newton Raphson para realizar as simulações
de no máximo 30 barras. O software ainda apresenta a possibilidade de desenvolver
um diagrama unifilar para a visualização e modificação da topologia da rede.
O trabalho de graduação (Antunes, 2007) também teve o objetivo de

desenvolver um software didático para cálculo de fluxo de potência. O programa
computacional recebeu o nome de “PF Analyst”, que apesar de se utilizar do MATLAB
como base de desenvolvimento, não tem vínculo nenhum com o mesmo para
funcionar. As bases de cálculos foram retiradas do MATPOWER, que é um pacote de
dados para cálculo de fluxo de potência do próprio MATLAB, desenvolvido por um
centro americano de pesquisas de engenharia elétrica voltado para a indústria, o
PSERC. A interface gráfica foi desenvolvida em C++ em uma plataforma de
aplicações para WINDOWS, o Borland C++ Builder 6. Contempla simulações de 6 até
118 barras utilizando os métodos de Newton Raphson tradicional e desacoplado,
linearizado e Gauss-Seidel.
Os trabalhos apresentados anteriormente têm o intuito de servir como

ferramenta auxiliadora no aprendizado e dinamizar o conteúdo sobre SEP (Sistema
Elétrico de Potência), porém nenhum deles apresenta uma versão mobile disponível
para smartphones. Com tudo isso, no país que é o líder no uso de aparelhos celular
entre os emergentes, a possibilidade de ter um software similar na palma da mão
mostra-se como um avanço nessa área de pesquisa, devido à praticidade de poder
realizar estudos em qualquer lugar.
1.5 Organização do Trabalho

Este trabalho foi dividido em 6 capítulos, nos quais descrevem toda a
problemática e desenvolvimento deste projeto.
19
No capítulo 1 foi definido os objetivos deste projeto e a metodologia. Também

foi apresentado o contexto cientifico que se encontra.
No capítulo 2 foi abordado o embasamento teórico para o desenvolvimento do

aplicativo falando da importância do fluxo de potência e o método de resolução dos
cálculos.
No capítulo 3 foi descrito a implementação do algoritmo de Newton-Raphson

na plataforma computacional, descrevendo os códigos fontes das funções utilizadas.
No capítulo 4 foi apresentada a análise de assertividade do aplicativo através

de testes comparativos com o ANAREDE.
No capítulo 5 foi descrito o processo de desenvolvimento da IHM e interação

com o algoritmo implementado na programação. Também foi exposto as
necessidades do usuário.
Por fim, no capítulo 6 é apresentado a conclusão final dos desenvolvedores

deste projeto e a sugestão de melhorias.
20
CAPÍTULO 02 - FUNDAMENTAÇÃO TEÓRICA PARA O CÁLCULO

DE FLUXO DE POTÊNCIA
No presente capítulo, o qual foi baseado em Gomes (2015) e Monticelli (2003), será
exposta a base dos fundamentos teóricos necessários para a resolução de problemas
envolvendo fluxo de potência em sistemas elétricos. Toda definição dos termos,
nomenclaturas e métodos matemáticos foram detalhados, de forma objetiva, a fim de
promover a compreensão do funcionamento do algoritmo inserido no aplicativo
desenvolvido neste trabalho.
2.1 Introdução ao Fluxo de Potência

O estudo do fluxo de potência é importante para determinação do planejamento
de regulação e operação dos sistemas elétricos de potência instalados no mundo. A
análise do fluxo observa a rede e seus respectivos componentes, a fim de determinar
os parâmetros de regulação e verificar o comportamento da relação geração/consumo
em um determinado momento de operação do sistema.
Existem dois tipos de análise do comportamento operacional de um sistema de

potência. Um deles é o “Estudo Dinâmico”, o qual analisa a rede em um regime
transitório de operação, ou seja, durante as variações de carga e/ou falhas no sistema.
O outro método é o “Estudo Estático”, que analisa o sistema em uma condição de
regime permanente de operação. Neste último, observa-se a rede e seus parâmetros
em um valor fixo, assim é possível definir o fluxo das potências entre as barras naquela
determinada condição de regulação dos parâmetros da rede.
Como o objetivo deste presente trabalho é proporcionar ao aluno, por meio do

aplicativo, a experiência de compreender o comportamento do fluxo de potência
mediante uma determinada condição de operação da rede e como o fluxo reage de
acordo com a variação dos parâmetros de regulação (tensão e ângulo de fase), optou-
se por desenvolver o aplicativo baseado no “Estudo Estático”.
Em seguida foram apresentados os fundamentos para a compreensão deste

método de análise de rede escolhido.
21
2.2 Parâmetros de Rede e Fundamentos do “Estudo Estático”

Para entender o funcionamento do fluxo dentro de uma rede é necessário
conhecer os componentes que a formam e os parâmetros de regulação que existem
dentro dela.
Uma rede elétrica, para efeito de análise do fluxo, é composta pelos seguintes
componentes:
• Barras: São subestações de transmissão, subtransmissão ou distribuição, nas
quais estão ligadas as cargas do sistema e as usinas de geração.
• Linhas de Transmissão: É o componente da rede responsável pela condução
do fluxo de potência entre as barras do sistema. Estas são representadas por
uma impedância, que possui os valores de resistência e reatância do condutor
utilizado.
• Capacitores Shunt: Quando a linha de transmissão é muito longa, deve-se

considerar a capacitância da linha, sendo assim, coloca-se um capacitor em
cada extremidade da linha para representar esta característica física da
mesma.
• Cargas: São os elementos da rede ligados às barras que representam o

consumo de potência ativa e/ou reativa do sistema.
Além dos componentes anteriormente apresentados, o sistema também possui

parâmetros que influenciam a condição operacional do sistema. Pois o fluxo de
potência tem sua variação em função do módulo da tensão e do ângulo de fase das
barras, como demonstrado nas equações (2.1) e (2.2). São estes os listados a seguir:
• Tensão na Barra: Este parâmetro é o módulo (em valor por unidade) da tensão
em uma determinada barra do sistema;
• Ângulo de Fase: Este outro parâmetro é a representação do ângulo da tensão

de fase em uma barra;
A seguir, na Figura 1, a representação de apenas duas barras, para melhor

visualização dos componentes interligados e onde estão estes parâmetros da rede.
22
Figura 1 - Exemplo de rede com 2 barras, uma linha, 2 Capacitores shunt.
Onde:
• Z é a impedância que representa a linha de transmissão;
• 𝐶𝑠ℎ representa a capacitância da linha de transmissão;
• “m” e “k” é a denominação dada para as barras;
• 𝑉𝑚 e 𝑉𝑘 são os módulos das tensões nas barras m e k respectivamente;
• 𝜃𝑘 𝑒 𝜃𝑚 são os ângulos de fase das tensões nas barras k e m respectivamente.
A partir da análise da rede através da lei de Kirchhoff são obtidas as equações

básicas de fluxo de carga (2.1) e (2.2). Estas expressões indicam que a injeção líquida
de potência, seja ativa ou reativa, em uma barra (neste caso, na “k”), é uma somatória
de equações dos fluxos que fluem entre as barras da rede, sendo que estes variam
em função das tensões e dos ângulos de fase das mesmas.
Observando a equação a partir da Figura 1, tem-se a relação de potência na

barra “k” dada a partir dos fluxos entre as “k” e “m”. Para o caso de mais barras, deve-
se considerar uma somatória dos fluxos entre as barras em estudo e as demais do
sistema, com as quais estiver interligada por meio de uma linha de transmissão.
𝑃𝑘 = ∑𝑚∈K 𝑃𝑘𝑚 (𝑉𝑘 , 𝑉𝑚 , 𝜃𝑘 , 𝜃𝑚 ) (2.1)
𝑄𝑘 + 𝑄𝑘𝑠ℎ = ∑𝑚∈𝐾 𝑄𝑘𝑚 (𝑉𝑘 , 𝑉𝑚 , 𝜃𝑘 , 𝜃𝑚 ) (2.2)

23
Onde:
• K é o total de barras do sistema, incluindo a barra k;
• 𝑃𝑘𝑚 : Fluxo de potência ativa entre as barras k e m;
• 𝑄𝑘𝑚 : Fluxo de potência reativa entre as barras k e m;
• 𝑄𝑘𝑠ℎ : Injeção de potência reativa devido ao elemento shunt conectado na barra

k.
Existem seis grandezas a serem consideradas na barra k:
• 𝑉𝑘 : Módulo da tensão;
• 𝜃𝑘 : Ângulo da tensão;
• 𝑃𝑘 : Potência ativa líquida injetada;
• 𝑄𝑘 : Potência reativa líquida injetada;
• 𝑉𝑚 : Módulo da tensão;
• 𝜃𝑚 : Ângulo da tensão.
2.3 Definição do Tipo das Barras

Durante a solução de um problema envolvendo o fluxo de potência, em geral,
tem-se conhecimento de algumas das grandezas elétricas dos sistemas, sejam elas
potências ativas, reativa, tensões ou ângulo de fase das barras, de acordo com o tipo
de barra, podendo ser do tipo PQ, PV ou Vθ, conforme exposto nos itens descritos a
seguir:
• Barra de carga ou PQ: Tem-se os valores das grandezas 𝑃𝑘 𝑒 𝑄𝑘 , portanto

calcula-se 𝑉𝑘 𝑒 𝜃𝑘 . Neste tipo de barra não existe dispositivos para o controle de
tensão;
• Barra PV: Tem-se os valores das grandezas 𝑃𝑘 𝑒 𝑉𝑘 , portanto calcula-se

𝑄𝑘 𝑒 𝜃𝑘 . Neste tipo de barra estão conectados dispositivos que controlam o
24
módulo da tensão e a injeção de potência ativa, tais como os geradores e

compensadores síncronos;
• Barra Vθ: Têm-se os valores das grandezas 𝑉𝑘 e θk , portanto calcula-se 𝑃𝑘 e

𝑄𝑘 . É nesta barra que se estabelece a referência de defasagem, assumindo
que a mesma possui ângulo 0º, e fecha o balanço de potência ativa e reativa
do sistema, levando em consideração as perdas do sistema de transmissão.
2.4 Convenção do Sentido do Fluxo

Para a facilitar os cálculos durante a solução dos problemas envolvendo o fluxo
de potência em grandes redes, foi adotado um sentido convencional para o fluxo, bem
como o sinal a ser representado o consumo (carga) e a geração de potência. Na
Figura 2 tem-se a representação do sentido adotado pela convenção. Sendo assim,
ao analisar as equações (2.1) e (2.2), considera-se que as injeções líquidas de
potência são positivas quando entram na barra (geração) e negativas quando saem
da barra (carga). Para os elementos shunt das barras é adotada a mesma convenção
para as injeções.
Figura 2 - Convenção do sentido de fluxo de potência (Fonte: MONTICELLI, Alcir, 2003)
2.5 Solução das Equações de Fluxo de Potência pelo Método de Newton-

Raphson
Utilizando um modelo para exemplo, em que inicialmente são fornecidos os
dados de 𝑃𝑘 e 𝑄𝑘 para as barras PQ, 𝑃𝑘 e 𝑉𝑘 para as barras PV e 𝑉𝑘 e 𝜃𝑘 nas barras
25
Vθ. Pretende-se calcular 𝑉𝑘 e 𝜃𝑘 nas barras PQ e 𝜃𝑘 nas barras PV. Quando este
problema for resolvido, serão obtidos os valores de 𝑉𝑘 e 𝜃𝑘 para todas as barras da
rede, sendo assim, será possível calcular 𝑃𝑘 e 𝑄𝑘 através das equações (2.1) e (2.2)
para as barras 𝑉𝜃, 𝑄𝑘 para as barras PV e outras variáveis de interesse.
Sendo NPQ e NPV o número de barras do tipo PQ e PV, respectivamente, tem-

se um sistema a ser resolvido, constituído por um total de 2NPQ + NPV equações e o
mesmo número de incógnitas.
As equações que compõem este sistema podem ser escritas do seguinte modo:
Para as barras PQ e PV tem-se a equação (2.3) da variação de potência ativa.
𝑒𝑠𝑝
Δ𝑃𝑘 = 𝑃𝑘 − 𝑃𝑘 (𝑉, 𝜃) = 0 (2.3)
Onde:
𝑒𝑠𝑝
𝑃𝑘 = Injeção de potência ativa especificada na barra k.
𝑃𝑘 = Injeção de potência ativa calculada em função de V e θ para a barra k.
Para as barras PQ, a equação (2.4) da variação de potência reativa.
𝑒𝑠𝑝
Δ𝑄𝑘 = 𝑄𝑘 − 𝑄𝑘 (𝑉, 𝜃) = 0 (2.4)
Onde:
𝑒𝑠𝑝
𝑄𝑘 = Injeção de potência reativa especificada na barra k.
𝑄𝑘 = Injeção de potência reativa calculada em função de V e θ para a barra k.
Seja 𝑔(𝑥 ) descrita pela expressão (2.5) uma função composta pelos valores
calculadas através das equações (2.3) e (2.4), em função do vetor “x” demonstradas
em (2.6), composto pelas incógnitas a serem determinadas:
Δ𝑃
𝑔 (𝑥 ) = [ ] (2.5)
Δ𝑄
26
𝜃
𝑥=[ ] (2.6)
𝑉
Sendo que, em (2.6), θ representa os ângulos (em radianos) das tensões das
barras PQ e PV, e, V, os módulos das tensões em p.u. (por unidade) das barras PQ.
O método de Newton-Raphson tem como objetivo encontrar o valor de x para

o qual a função g(x) tenha um resultado nulo, ou seja, em que o conjunto das potências
residuais em (2.5) seja igual a 0, e, sendo esta solução correspondente ao ponto em
que a curva g(x) da Figura 3 corta o eixo x. Portanto, determinar os valores de 𝜃𝑘 e 𝑉𝑘
para os quais as potências ativa e reativa calculadas 𝑃𝑘 e 𝑄𝑘 sejam iguais às
𝑒𝑠𝑝 𝑒𝑠𝑝
especificadas 𝑃𝑘 e 𝑄𝑘 , zerando as equações (2.3) e (2.4).
Figura 3 - Método de Newton Raphson (Fonte: MONTICELLI, Alcir, 2003; p.217)
a) Passo 01
Deve-se criar um valor de uma variável para ser um contador de iterações,

incialmente h=0, e escolhem-se os valores iniciais de 𝑥 = 𝑥 (ℎ) = 𝑥 (0), ou seja, 𝜃𝑘 =
(0)
𝜃𝑘 e 𝑉𝑘 = 𝑉𝑘 (0) para suas respectivas barras.
27
b) Passo 02
Calcula-se o valor da função g(x) no ponto 𝑥 = 𝑥 (ℎ), ou seja, 𝑃𝑘 (𝑉 (ℎ) , 𝜃 (ℎ) ) e

𝑄𝑘 (𝑉 (ℎ) , 𝜃 (ℎ) ) para suas respectivas barras, utilizando as equações (2.1) e (2.2),
respectivamente.
(ℎ) (ℎ)
Posteriormente, determinam–se os resíduos Δ𝑃𝑘 e Δ𝑄𝑘 , ou seja, a diferença
entre os valores especificados e os calculados.
c) Passo 03
Compara-se os módulos dos valores calculados de 𝑔(𝑥 (ℎ) ) com a tolerância

(ℎ) (ℎ)
especificada ε. Caso |Δ𝑃𝑘 | ≤ 𝜀 e |Δ𝑄𝑘 | ≤ 𝜀, o processo iterativo convergiu para a
solução (𝑉 (ℎ) , 𝜃 (ℎ) ), e, portanto, os vetores em 𝑥 (ℎ) são a solução para g(x) = 0. Caso
contrário passa-se ao próximo passo, até que sejam alcançados valores dentro da
margem de erro.
d) Passo 04
Lineariza-se a função g(x) em torno do ponto (𝑥 (ℎ) : 𝑔(𝑥 (ℎ) )) por intermédio da
𝜕𝑔
série de Taylor, conforme equação (2.7), sendo que 𝑔′ (𝑥 ) = 𝜕𝑥 .
𝑔(𝑥 ℎ + Δ𝑥 ℎ ) ≅ 𝑔(𝑥 ℎ ) + 𝑔′ (𝑥 ℎ )Δ𝑥 (2.7)
Para prosseguir com o cálculo de fluxo de potência pelo método de Newton-

Raphson, em redes com mais de 2 barras, é necessário definir a Jacobiana, que é a
matriz de sensibilidade, representada em (2.8), a qual calcula a alteração do vetor “x”
conforme variação da função g(x) através das derivadas parciais expostas nas
equações (2.9) a (2.16).
𝛿𝑃 𝛿𝑃
(ℎ) 𝛿𝜃 𝛿𝑉 𝐻 𝑁
𝐽 = [𝛿𝑄 𝛿𝑄
] =[ ] (2.8)
𝑀 𝐿
𝛿𝜃 𝛿𝑉
28
Esta matriz é chamada de sensibilidade, pois por meio dela é possível

determinar quanto é a variação de um valor de potência (ativa ou reativa) em função
da variação dos parâmetros de tensão e ângulo de fase das barras.
Analisando a matriz expressa na equação (2.8), pode-se observar que os

índices “H” e “N” são correspondentes a variação de potência ativa, sendo “H” em
função do ângulo de fase e “N” em função da tensão de fase. Os índices “M” e “L”
representam a variação de potência reativa, onde “M” corresponde a variação em
função do ângulo e ‘L” em função da tensão de fase.
Para o exemplo de duas barras (k e m) conforme a rede descrita na Figura 1,

tem-se então os elementos da matriz Jacobiana (H, N, M e L), obtidos com as
derivadas parciais expressas em (2.9) a (2.16). Estas equações são obtidas por meio
da derivação das equações de injeção líquida de potência (ativa ou reativa) de uma
barra (k ou m) em função de um parâmetro (V ou 𝜃) de uma das barras da rede (no
exemplo da Figura 1 são as barras k e m).
Nas seguintes equações tem-se a primeira letra como identificação do

elemento da matriz (H, N, M ou L), depois há uma letra que representa a barra na qual
está em análise as equações de injeção líquida de potência ativa e reativa (k ou m) e
em seguida é a letra correspondente a barra do parâmetro com a qual está relacionada
à sensibilidade (V ou 𝜃).
𝛿𝑃
𝐻𝑘𝑚 = 𝛿𝜃 𝑘 = 𝑉𝑘 𝑉𝑚 (𝐺𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 − 𝐵𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 ) (2.9)
𝑚
𝛿𝑃𝑘
𝐻𝑘𝑘 = = −𝑉𝑘2 𝐵𝑘𝑘 − 𝑉𝑘 ∑𝑚∈𝜙𝑘 𝑉𝑚 (𝐺𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 − 𝐵𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 ) (2.10)
𝛿𝜃𝑘
𝛿𝑃
𝑁𝑘𝑚 = 𝛿𝑉 𝑘 = 𝑉𝑘 (𝐺𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 + 𝐵𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 ) (2.11)
𝑚
𝛿𝑃
𝑁𝑘𝑘 = 𝛿𝑉𝑘 = 𝑉𝑘2 𝐺𝑘𝑘 + ∑𝑚∈𝜙𝑘 𝑉𝑚(𝐺𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 + 𝐵𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 ) (2.12)
𝑘
𝛿𝑄
𝑀𝑘𝑚 = 𝛿𝜃 𝑘 = −𝑉𝑘 𝑉𝑚 (𝐺𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 + 𝐵𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 ) (2.13)
𝑚
𝛿𝑄
𝑀𝑘𝑘 = 𝛿𝜃𝑘 = −𝑉𝑘2 𝐺𝑘𝑘 + 𝑉𝑘 ∑𝑚∈𝜙𝑘 𝑉𝑚(𝐺𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 + 𝐵𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 ) (2.14)
𝑘
𝛿𝑄
𝐿𝑘𝑚 = 𝛿𝑉 𝑘 = −𝑉𝑘 (𝐺𝑘𝑚 sin 𝜃𝑘𝑚 − 𝐵𝑘𝑚 cos 𝜃𝑘𝑚 ) (2.15)
𝑚
29
𝛿𝑄
𝐿𝑘𝑘 = 𝛿𝑉𝑘 = −𝑉𝑘2 𝐵𝑘𝑘 + ∑𝑚∈𝜙𝑘 𝑉𝑚(𝐺𝑘𝑚 sin 𝜃𝑘𝑚 − 𝐵𝑘𝑚 cos 𝜃𝑘𝑚 ) (2.16)
𝑘
Pode-se observar que existem vários tipos de equação para uma rede simples
com duas barras, porém para a montagem da matriz são necessários somente 4
elementos, sendo assim, faz-se necessário a escolhas de 4 das equações listadas
para então prosseguir com a solução da matriz.
Esta escolha é determinada pelo tipo das barras em questão e pelos valores
de grandezas (potência ativa e reativa) que já são conhecidos previamente.
Se em uma rede de duas barras tem-se uma barra “m” de referência V𝜃 (onde
é conhecido o valor de tensão e ângulo de fase) e uma barra “k” do tipo PV (onde é
conhecido a potência ativa e a tensão de fase), tem-se então a escolha dos seguintes
elementos para a montagem da matriz:
𝛿𝑃
𝐻𝑘𝑘 = 𝛿𝜃𝑘 (2.17)
𝑘
𝛿𝑃
𝑁𝑘𝑘 = 𝛿𝑉𝑘 (2.18)
𝑘
𝛿𝑄𝑘
𝑀𝑘𝑘 = (2.19)
𝛿𝜃𝑘
𝛿𝑄
𝐿𝑘𝑘 = 𝛿𝑉𝑘 (2.20)
𝑘
Caso a barra do tipo PV fosse a de identificação “m”, os índices das potências

e as equações a serem escolhidas seriam do tipo 𝑃𝑚 e 𝑄𝑚 , e o de parâmetros seria
𝜃𝑚 e 𝑉𝑚 .
e) Passo 05
Determinando os valores de H, N, M e L, e os residuais das potências (obtidos
no passo 02) obtém-se a matriz jacobiana em (2.21), possibilitando calcular as
variações de 𝜃𝑘 e 𝑉𝑘 .
Δ𝑃 𝐻 𝑁 Δ𝜃
[ ]=[ ][ ] (2.21)
Δ𝑄 𝑀 𝐿 Δ𝑉
30
f) Passo 06
Determinam-se, então, o novo valor para o vetor 𝑥 (ℎ+1) = 𝑥 (ℎ) + Δ𝑥 (ℎ) ,
utilizando as equações (2.22) e (2.23).
𝜃 ℎ+1 = 𝜃 ℎ + Δ𝜃 (2.22)
𝑉 ℎ+1 = 𝑉 ℎ + ΔV (2.23)
g) Passo 07
Para iniciar a próxima iteração, faz-se ℎ′ = ℎ + 1 e retorna-se ao passo 02.
Repete-se este passo a passo até que, no item 03, se obtenha valores dentro
da margem de erro. Sendo que esta é determinada por quem está solucionando o
problema.
2.6 Exemplo para Referência

Tendo como demonstração, o exemplo da referência (MONTICELLI, 2003) com
duas barras conforme descrito na Figura 4, sendo a incógnita 𝜃2 e a equação 𝑃2 para
a barra 2, com base nos parâmetros fornecidos pelas tabelas 1 e 2, e, considerando
uma tolerância (ε) de 0,001 p.u., será solucionado através do método de Newton-
Raphson, exposto nos passos 01 a 07:
Figura 4 - Rede de duas barras
Tabela 1 - Dados da rede de 2 barras Tabela 2 - Dados de impedância da linha em p.u.

Barra Tipo P(p.u.) Q(p.u.) V(p.u.) Θ(rad.) Linha R X 𝒃𝒔𝒉
1 Vθ - - 1,0 0 1-2 0,05 0,1 0,02
2 PV - 0,4 - 1,0 -
31
2.6.1 Determinação das Matrizes de Condutância e Susceptância.

Com base nos dados de impedância apresentados na tabela 2, tem-se a
seguinte admitância:
𝑦12 = 𝑔12 + 𝑗𝑏12 = (𝑧12 )−1 = (0,05 + 𝑗0,1)−1 = 𝟒 − 𝒋𝟖
Com isso, tem-se a matriz admitância nodal, que pode ser subdivida em
condutância (G) e susceptância (B). Sendo que seus componentes são necessários
para que que sejam montadas as equações (2.1) e (2.2).
4 − 𝑗7,98 −4 + 𝑗8,0
𝑌 = 𝐺 + 𝑗𝐵 = [ ]
−4 + 𝑗8,0 4 − 𝑗7,98
4 −4 −7,98 8,0
𝐺=[ ] 𝐵=[ ]
−4 4 8,0 −7,98
Desenvolvendo as equações (2.1) e (2.2) com base no exemplo proposto, e,

em seguida, substituindo os valores obtidos nas matrizes demonstradas acima,
obtém-se:
𝑃2 = 𝑉2 2 𝐺22 + 𝑉2 𝑉1 (𝐺21 cos 𝜃21 + 𝐵21 sin 𝜃21 ) = 𝟒 − 𝟒 𝐜𝐨𝐬 𝜽𝟐 + 𝟖 𝐬𝐢𝐧 𝜽𝟐
2.6.2 Cálculos Referentes a Primeira Iteração.

Após descrita as equações da rede, começa o passo a passo a fim de encontrar
as incógnitas desejadas. Usualmente, inicia-se adotando 1 p.u. para as tensões e 0
radianos para os ângulos a serem calculados.
a) Passo 01:
Para a primeira iteração (h=0), tem-se 𝜃2 (0) = 0,0 𝑟𝑎𝑑.
32
b) Passo 02:
Para determinação de 𝑃2 (𝜃2 (ℎ) ), para a barra 2 do tipo PV, utilizando a equação
2.1 e adotando os valores iniciais das incógnitas apontados no passo anterior, tem-
se:
𝑃2 = 4(1 − cos 𝜃2 (ℎ) ) + 8 sin 𝜃2 (ℎ) ∴ 𝑃2 (𝜃2 (0) ) = 0
Com isso, calcula-se o residual utilizando a equação 2.3:
Δ𝑃2 (𝜃2 (0) ) = −0,40 − 0 = −0,40
c) Passo 03:
Neste caso, o processo continua, devido ao residual ainda ser maior que a
tolerância.
(ℎ)
|Δ𝑃𝑘 | > 𝜀 , 𝑝𝑜𝑖𝑠 0,40 > 0,001
d) Passo 04:
Como este sistema contém somente 2 barras, sendo uma V𝜃 e outra 𝑃𝑉, para
solucionar todas as equações de potência ativa e reativa, necessita-se somente de
descobrir o valor de 𝜃2 , pois já se tem conhecimento sobre as demais incógnitas.
Sendo assim, para identificar o valor da incógnita em questão, calcula-se a variação de 𝑃2
(0)
em função de 𝜃2 , utilizando o elemento 𝐻𝑘𝑘 da matriz jacobiana, exposto na equação
(2.10).
𝛿𝑃
𝐻𝑘𝑘 = 𝛿𝜃𝑘 = −𝑉𝑘2 𝐵𝑘𝑘 − 𝑉𝑘 ∑𝑚∈𝜙𝑘 𝑉𝑚 (𝐺𝑘𝑚 𝑠𝑖𝑛 𝜃𝑘𝑚 − 𝐵𝑘𝑚 𝑐𝑜𝑠 𝜃𝑘𝑚 )
𝑘
Considerando, conforme apresentado nas matrizes, 𝐵𝑘𝑘 = −7,98; 𝐵𝑘𝑚 =

8,0 ; 𝐺𝑘𝑘 = 4,0; 𝐺𝑘𝑚 = −4,0.
𝜕𝑃2
(0) = −(12 × −7,98) − 1 × [1 × (−4 sin 𝜃21 − 8 𝑐𝑜𝑠 𝜃21 ) + 1 × (4 sin 𝜃22 −
𝜕𝜃2
(−7,98) 𝑐𝑜𝑠 𝜃22 )]

33
Sendo que: 𝜃21 = 𝜃2 − 𝜃1 = 𝜃2 − 0 = 𝜃2 e 𝜃22 = 𝜃2 − 𝜃2 = 0.
𝜕𝑃2
Chega-se ao resultado: (0) = 4 si n𝜃2 + 8 co s𝜃2 = 8
𝜕𝜃2
e) Passo 05:
Assim, torna-se possível calcular a variação de 𝜃2 para próxima iteração:
𝜕𝑃2 (0)
[Δ𝑃2 ] = [ (0) ] × [Δ𝜃2 ]
𝜕𝜃2
(0) Δ𝑃2 0,40

Δ𝜃2 = =− = −0,05 𝑟𝑎𝑑
𝜕𝑃2 8
[ (0)
]
𝜕𝜃2
f) Passo 06:
Com isso, o próximo valor de 𝜃2 para próxima iteração é:
(0) (0) (1)

𝜃2 ℎ+1 = 𝜃2 + Δ𝜃2 ∴ 𝜃2 = 0,0 + (−0,05) = −𝟎, 𝟎𝟓 𝒓𝒂𝒅
g) Passo 07:
h’ = 0+1 = 1, dando início à próxima iteração.
2.6.3 Cálculos Referentes a Segunda Iteração

Visto que a iteração continua, utiliza-se os valores das incógnitas obtidos no
passo 6 para obter as novas potências calculadas, para que as mesmas se aproximem
cada vez mais de zero (ou da tolerância admitida).
a) Passo 02:
(1)
Com 𝜃2 = −0,05 𝑟𝑎𝑑, obtém-se um novo valor de 𝑃2 (𝜃2 (ℎ) ):
34
𝑃2 = 4(1 − cos 𝜃2 ) + 8 sin 𝜃2 ∴ 𝑃2 (𝜃2 (1) ) = −0,3948
Portanto, o residual passa a ser:
Δ𝑃2 (𝜃2 (1) ) = −0,40 + 0,3948 = −0,0052
b) Passo 03:
Novamente o processo continua, pois, o residual ainda é maior que a tolerância.
|Δ𝑃21 | = 0,0052 > 0,001
c) Passo 04:
(1)
Calcula-se a variação de 𝑃2 em função de 𝜃2 :
𝜕𝑃2
(1) = 4 sin 𝜃2 + 8 cos 𝜃2 = 7,79
𝜕𝜃2
d) Passo 05:
Assim, calcula-se a nova variação de 𝜃2 para próxima iteração:
(1) Δ𝑃2 0,0052

Δ𝜃2 = 𝜕𝑃2 =− = −0,0007 𝑟𝑎𝑑
7,79
(0)
𝜕𝜃2
e) Passo 06:
Com isso, o próximo valor de 𝜃2 para próxima iteração passa a ser:
(1) (1) (2)

𝜃2 ℎ+1 = 𝜃2 + Δ𝜃2 ∴ 𝜃2 = −0,05 + (−0,0007) = −𝟎, 𝟎𝟓𝟎𝟕 𝒓𝒂𝒅
f) Passo 07:
h’’ = 0+2 = 2, dando início à próxima iteração.

35
2.6.4 Cálculos Referentes a Terceira Iteração

Novamente, utilizando as novas incógnitas (sendo neste exemplo, apenas 𝜃2 ),
inicia-se uma nova iteração. E assim, sucessivamente, até que os valores de x (2.6)
sejam suficientes para convergir, pois, quando isto ocorrer, os mesmos serão a
solução.
a) Passo 02:
𝑃2 = 4(1 − cos 𝜃2 ) + 8 sin 𝜃2 ∴ 𝑃2 (𝜃2 (2) ) = −0,400
Δ𝑃2 (𝜃2 (2) ) = −0,40 + 0,400 = 0
b) Passo 03:
Nesta iteração, o módulo do residual está dentro da margem de tolerância.

(𝟐)
Portanto a solução para 𝜃2 é 𝜽𝟐 = −𝟎, 𝟎𝟓𝟎𝟕 𝒓𝒂𝒅.
|Δ𝑃2 2 | = 0,0 < 0,001
Através da solução desta incógnita, torna-se possível calcular (utilizando as

equações (2.1) e (2.2)) os demais dados da barra, como 𝑃1 , 𝑄1 𝑒 𝑄2 .
2.7 Conclusões Parciais

Nesta parte do trabalho foram obtidas as seguintes conclusões:
• A fundamentação teórica apresentada neste capitulo é a base de toda

metodologia de cálculo utilizada para estruturação do aplicativo para solução
de problemas envolvendo fluxo de potência. Foram apresentadas todas as
definições dos equipamentos de uma rede (considerados para o aplicativo) e
os parâmetros que interferem diretamente no fluxo de potência entre as barras
do sistema;
• Para proporcionar ao usuário do aplicativo a capacidade de identificar como o
fluxo se comporta em uma rede, mediante os parâmetros de regulação, foi
36
demonstrado o “Estudo Estático” como melhor alternativa. Este permite que o

usuário tenha uma visão momentânea do fluxo em uma determinada condição
de operação. Sendo assim, caso seja alterado algum parâmetro na rede, o fluxo
sofrerá alteração. Desta forma o usuário conseguirá entender os conceitos que
envolvem o fluxo de potência em uma rede. Por se tratar de um sistema de
equações não lineares, foi necessário a aplicação de um método iterativo para
solucionar as equações em questão. Para tal solução matemática, considerou-
se o método iterativo de Newthon-Raphson;
• No item 2.6, tem-se a apresentação de um passo a passo realizado para
solução de um sistema com apenas 2 barras e uma linha de transmissão na
rede, a fim de proporcionar um entendimento prático da aplicação dos
fundamentos teóricos ensinados anteriormente. Desta maneira é possível
concluir que um leitor de posse da compreensão dos fundamentos e
metodologias apresentados no presente capítulo tem total capacidade de
entender e se familiarizar de forma simples com o aplicativo desenvolvido por
este projeto.
37
CAPÍTULO 03 – ESTRUTURAÇÃO E IMPLANTAÇÃO DO APLICATIVO

PARA CÁLCULO DO FLUXO DE POTÊNCIA
No presente capítulo será apresentada a linguagem de programação escolhida, assim
como realizar uma abordagem da implementação dos algoritmos para resolução de
problemas de cálculo de fluxo de potência na plataforma de desenvolvimento do
aplicativo, nomeado como “Power Flow”. Também será exposto o fluxograma
orientativo do processo de cálculo, e por fim, os testes de assertividade e limites do
algoritmo.
3.1 Definição da Plataforma para Implantação do Conjunto de Algoritmos para

o Cálculo de Fluxo de Potência
Como todo e qualquer tipo e projeto a ser realizado, é necessário definir os
objetivos, pois é através destes que serão selecionadas as ferramentas que melhor
poderão atender as necessidades tanto dos programadores, quanto dos usuários.
a) Determinação das necessidades básicas
No caso do aplicativo desenvolvido, existe a necessidade de utilização de

linguagens de programação que possuam bibliotecas com funções matemáticas
como: formação de equações, derivação de equações etc. Linguagem que possua
fácil entendimento dos códigos, uma vez que o grupo responsável pelo projeto não
tem suas habilidades focadas em programação, também é de extrema importância
que esta linguagem permita a elaboração de interfaces gráficas para apresentação ao
usuário do aplicativo. Esta deve possuir capacidade de compilação dos códigos para
arquivos de plataformas diferentes, uma vez que o diferencial deste aplicativo é a
utilização em multiplataformas.
38
b) Análise das Linguagens de Programação
Diante de tais necessidades foi optado pelo uso da linguagem WEB, pois a
mesma possibilita o desenvolvimento de softwares utilizando a tecnologia HTML, CSS
e JavaScript e tem várias finalidades que podem ser desde uma propaganda animada
de uma página da internet até um aplicativo que cálculo fluxo de potência, vale
destacar que, cada linguagem de programação em uma aplicação WEB interage entre
si e é responsável por uma parte de sua estrutura. Tal sistema é formado por uma
parte estática que utiliza as linguagens HTML e o CSS para criar o layout da tela para
inserção de dados e uma dinâmica que foi desenvolvida a partir do JavaScript sendo
esta responsável pela lógica do aplicativo e a operacionalização dos algoritmos.
Na programação do aplicativo, devido a necessidade de números complexos e

matrizes, foram utilizadas as bibliotecas: Math.js que habilita tais funções
matemáticas; Pace.js, para tornar as telas de carregamento mais amigáveis e a
denominada Jquery que habilita o banco de dados para utilização do programa
Phonegap.
Como o aplicativo para cálculo de fluxo de potência utiliza-se de linguagem

WEB, os códigos podem ser escritos em um simples editor de textos como o Bloco de
Notas até softwares pagos a níveis profissionais que disponibilizam funções auxiliares
para a programação. Por fim, optou-se por utilizar o Notepad++ na construção da
estrutura do código do aplicativo, pois além do software ser gratuito e apresentar
suporte para programação de aplicações WEB, o mesmo possui recurso de
diferenciação de comandos por cores e numeração de linhas, o que ajuda na
resolução de problemas nos códigos como por exemplo erro de digitação. Mesmo não
sendo um aplicativo de porte comercial, o cálculo de fluxo de potência pelo método de
Newton-Raphson demanda muitas linhas de comando, não só pelos cálculos em si,
mas também pela determinação dos elementos da rede e a formação da matriz
admitância que dá início à resolução do problema.
Uma vez que a plataforma e linguagem de programação estão definidas de

acordo com as necessidades do aplicativo, porém, somente por meio de análises e
estudos, é necessário a realização de testes para verificar o atendimento aos
requisitos citados anteriormente neste capítulo.
39
3.2 Implementação do Conjunto de Algoritmos para o Cálculo do Fluxo de

Potência
Para a elaboração de qualquer aplicativo, ferramenta ou software para
realização de qualquer tipo de função matemática é necessário o desenvolvimento de
algumas etapas prévias. O processo utilizado para a implantação em questão foi
descrito a seguir.
3.2.1 Determinação do Fluxograma do Processo do Cálculo de Fluxo de

Potência
Todo algoritmo deve seguir um determinado fluxo de ações e de informações
para que então seja obtido os resultados esperados. Se tratando de uma lógica de
funções matemáticas não é diferente. Sendo assim para a elaboração do código, foi
utilizado um fluxograma que exibe de forma simplificada a ordem das ações a serem
realizadas pelo aplicativo.
Para o desenvolvimento do aplicativo utilizou-se um procedimento de inserção

de dados e um fluxo de cálculo determinado previamente pela programação do
mesmo. Na Figura 5 tem-se a representação do Fluxograma que baseia o algoritmo
desenvolvido para solucionar problemas envolvendo fluxo de potência em uma rede.
Figura 5 - Fluxograma básico do cálculo de fluxo de potência

40
Neste fluxograma é possível identificar todas as etapas do processo do cálculo

para solucionar o problema em questão. Também é estabelecido os pontos de
interação do usuário com o aplicativo, de forma que este é responsável pela inserção
dos dados da rede em análise. Uma vez sendo o cálculo realizado tem-se a
demonstração dos resultados na interface gráfica.
3.2.2 Desenvolvimento dos Códigos Utilizados para o Cálculo de Fluxo de

Potência Envolvendo Duas Barras
Após a definição das plataformas e dos processos a serem realizados para a
solução dos problemas envolvendo o fluxo de potência, foram elaborados diversos
códigos para as inúmeras funcionalidades previstas, os mesmos são apresentados a
seguir.
a) Descrição do código para a realização da interface para inserção de

dados
Por ser uma plataforma de teste com poucos dados a serem inseridos, foi
desenvolvido uma IHM (Interface Homem Máquina) com uma única tela inicial de
inserção de dados previamente programada através do HTML. Nesta tela estão
disponíveis a seleção do tipo de uma das barras, os valores das linhas e os valores
dos parâmetros de cada uma das barras. Para criação da interface em questão foi
desenvolvido um código cujos comandos estão descritos a seguir:
</script>
</head>
<body>
<p align=center> DADOS DAS LINHAS (P.U)</p>

<table align=center border="3">
<tr align=center>
<td>Linha</td>
<td>rs</td>
<td>xs</td>
<td>jb<sup>sh</sup></td>
</tr>
<tr align=center>
41
<td>1-2</td>
<td>
<input type=“text” maxlength="7" name=“rs” id="rs" onKeyUp="decimal(this);"
onkeypress="return keypressed( this , event );" />
</td>
<td>
<input type=“text” maxlength="7" name=“xs” id="xs" onKeyUp="decimal(this);"
onkeypress="return keypressed( this , event );" />
</td>
<td>
<input type=“text” maxlength="7" name=“jbsh” id="jbsh"
onKeyUp="decimal(this);" onkeypress="return keypressed( this , event );" />
</td>
</tr>
</table>
<p align=center> DADOS DO SISTEMA (P.U.)</p>
<table id="DADOS" align=center border="3">
<tr align=center>
<td>Barra</td>
<td>Tipo</td>
<td>P</td>
<td>Q</td>
<td>V</td>
<td>θ</td>
</tr>
<tr align=center>
<td>1</td>
<td>V0 (Referência)</td>
<td>valor 1.1</td>
<td>valor 1.2</td>
<td>1</td>
<td>0</td>
</tr>
<tr align=center>
<td>2</td>
<td>
<select id="selectid" name="select" onchange="ativacampos()">
<option value="PV" selected>PV</option>
<option value="PQ">PQ</option>
</select>
</td>
<td><input type=“text” maxlength="7" name=“campoP” id="campoP"
onKeyUp="decimal(this);" onkeypress="return keypressed( this , event );" /></td>
<td><input type=“text” maxlength="7" name=“campoQ” id="campoQ"
onKeyUp="decimal(this);" onkeypress="return keypressed( this , event );"
disabled/></td>
42
<td><input type=“text” maxlength="7" name=“campoV” id="campoV"

onKeyUp="decimal(this);" onkeypress="return keypressed( this , event );" /></td>
<td><input type=“text” maxlength="7" name=“campoTeta” id="campoTeta"
onKeyUp="decimal(this);" onkeypress="return keypressed( this , event );"
disabled/></td>
</tr>
</table>
<button onclick="selecionarequação()">CALCULAR</button>
</body>
</html>
Como resultado do código acima descrito, tem-se a apresentação da IHM do

algoritmo de teste na Figura 6, onde pode-se visualizar a interface do programa beta.
Figura 6 - Painel de inserção de dados
b) Desenvolvimento do código para a realização da lógica para inserção de

dados na tabela da IHM
Para inserção dos dados nas tabelas foi desenvolvido um código que permite
automaticamente a liberação de digitação dentro dos campos de parâmetros (potência
ativa, potência reativa, ângulo de fase da tensão e módulo da tensão) de acordo com
a barra em questão (sendo do tipo PQ ou PV), o código em questão possibilita que
seja inserido um ponto para indicar a separação decimal e o bloqueio de inserção de
dados que não fazem parte do problema a ser analisado. A seguir o código que
permite a realização das funções anteriormente citadas:
<!DOCTYPE html>
<html lang="pt-br">
<head>
<title> 2 Barras </title>
43
<script language="javascript">
function keypressed( obj , e ) {

var tecla = ( window.event ) ? e.keyCode : e.which;
var texto = document.getElementById("rs").value
var indexvir = texto.indexOf(",")
var indexpon = texto.indexOf(".")
if ( tecla == 8 || tecla == 0 )// tecla 8 backspace, tecla 44 ",", tecla 46 ".", teclas do
48 ao 57: numeros do 0 ao 9
return true;
if ( tecla != 44 && tecla != 46 && tecla != 45 && tecla < 48 || tecla > 57 )
return false;
if (tecla == 44) { if (indexvir !== -1 || indexpon !== -1) {return false} }
if (tecla == 46) { if (indexvir !== -1 || indexpon !== -1) {return false} }
}
var selecionado;
function ativacampos()
{
selecionado = document.getElementById("selectid").value;
if(selecionado=="PV")
{
document.getElementById("campoP").disabled = false;
document.getElementById("campoQ").disabled = true;
document.getElementById("campoV").disabled = false;
document.getElementById("campoQ").value = "";
}
else //selecionado é PQ
{
document.getElementById("campoP").disabled = false;
document.getElementById("campoQ").disabled = false;
document.getElementById("campoV").disabled = true;
document.getElementById("campoV").value = "";
}
}
function decimal(z){
v = z.value;
v=v.replace(/[^-0-9]/,"") //permite digitar apenas números e o símbolo de negativo
v = v.replace(/(\d{1})(\d{3})$/, "$1.$2"); //coloca ponto automaticamente
z.value = v;
}
44
c) Código referente a seleção do tipo de barra
Uma vez que o tipo de barra é selecionado e os de dados referente aos

parâmetros de linha e barra são inseridos, o algoritmo pode dar início ao processo de
cálculos. Após o comando de início dos cálculos (através do botão “CALCULAR”), o
algoritmo define as incógnitas e as equações das barras do sistema em questão. O
código descrito a seguir é responsável por identificar a barra selecionada e direcionar
o algoritmo para a resolução adequada:
function selecionarequação(){
selecionado = document.getElementById("selectid").value;
if(selecionado=="PV"){
barraPV();
}
else{
barraPQ()};
}
d) Código para o procedimento para inserção dos dados no processamento

do cálculo para barra PV
Os valores a serem inseridos na tabela de dados da interface WEB são

transferidos para variáveis criadas dentro do programa, para que então sejam
utilizados posteriormente na resolução do problema. Sendo a barra em questão
selecionada como do tipo PV, o algoritmo insere nas variáveis os dados: Potência
Ativa e Módulo da Tensão. O código a seguir demonstra como o algoritmo insere
esses dados no processamento dos cálculos por meio das variáveis.
function barraPV(){
var rs=document.getElementById("rs").value;
var xs=document.getElementById("xs").value;
var P2=document.getElementById("campoP").value;
var V2=document.getElementById("campoV").value;
var G22=rs/((rs*rs)+(xs*xs));//convertendo em condutância
var G21=-G22;
var B21=-(-xs/((rs*rs)+(xs*xs)));//convertendo em susceptância
theta=0;
45
e) Desenvolvimento do código para a realização da criação e resolução da

equação da barra PV
O código a seguir é responsável pela elaboração das equações, criação das

derivadas e processo iterativo. Sendo esta rede com duas barras onde uma é de
referência e outra do tipo PV, não há necessidade de criação de uma matriz
admitância. Durante o processo iterativo do código, ele verifica se o valor da incógnita
encontrada resolve a equação de forma que o resultado possua erro inferior a 0,1%,
através dos comandos “do” e “while”.
do {
var V2aoquadrado= Math.pow(V2,2);
var costheta2= Math.cos(theta);
var sentheta2= Math.sin(theta);
var deltaP2=P2-((G22*V2aoquadrado)+(G21*V2*costheta2)+(B21*V2*sentheta2));
var modulodeltaP2= Math.abs(deltaP2);
var deriv=G21*V2*sentheta2+B21*V2*costheta2;
var y=deltaP2/deriv;
var t=theta+y;
theta=t;
} while (modulodeltaP2 > 0.001); // comparação do resultado com erro admitido de
0,1%
f) Código para operacionalizar o processo iterativo
Após o processo iterativo e a identificação da incógnita que atende ao

parâmetro do erro definido, o programa apresenta em forma de alerta dentro da página
WEB o valor encontrado. O código a seguir é responsável pela exibição dos
resultados:
var provareal=(G22*V2aoquadrado)+(G21*V2*costheta2)+(B21*V2*sentheta2);
alert(theta); // Exibição do resultado da incógnita em questão por meio de um “alet”
}
Na Figura 7 está representado graficamente o alerta contendo o valor da

incógnita encontrado por meio da resolução da equação da barra PV anteriormente
citado no código.
46
Figura 7 - Exibição do valor da incógnita
g) Código que realiza a introdução dos dados no processamento do cálculo

para barra PQ
Para o caso em que o usuário tenha selecionado uma barra do tipo PQ, é
executado um código diferente, porém que segue a mesma linha de raciocínio descrito
anteriormente. Neste caso os valores de potência ativa e reativa devem ser inseridos
nos campos dentro da tabela da IHM. A seguir é exibido o código responsável pela
captação dos dados inseridos pelo usuário e criação das variáveis contendo estes
valores, para que posteriormente sejam usados nos cálculos, também é apresentada
a conversão dos valores de impedância das linhas em admitâncias das linhas.
function barraPQ()
{
var rs=document.getElementById("rs").value;
var xs=document.getElementById("xs").value;
var P2=document.getElementById("campoP").value;
var Q2=document.getElementById("campoQ").value;
var V2=1;
var G22=rs/((rs*rs)+(xs*xs));
var G21=-G22;
var B21=-(-xs/((rs*rs)+(xs*xs)));
var B22=(-xs/((rs*rs)+(xs*xs)));
theta=0;
h) Código para a criação e resolução da equação da barra PQ
Nesta configuração de rede são geradas duas incógnitas, sendo uma o módulo
da tensão e o ângulo de fase da barra PQ. O código a seguir, define a matriz a as
equações de injeção líquida de potência a serem utilizadas para o cálculo.
do {
47
var V2aoquadrado= Math.pow(V2,2);

var costheta2= Math.cos(theta);
var sentheta2= Math.sin(theta);
var deltaP2=P2-(V2*(G21*costheta2+B21*sentheta2)+V2aoquadrado*G22); //
criação das equações
var deltaQ2=Q2-(V2*(G21*sentheta2-B21*costheta2)-V2aoquadrado*B22); //
criação das equações
var modulodeltaP2= Math.abs(deltaP2);
var modulodeltaQ2= Math.abs(deltaQ2);
i) Desenvolvimento do código para realizar a derivação das equações de

injeção líquida de potência
Uma vez as equações definidas, conforme apresentado no item anterior,

desenvolve-se um código para derivação destas em função das incógnitas deste
sistema em análise. O código a seguir exemplifica a formação das derivadas das
equações de injeção líquida de potência utilizada:
var derivP2theta2=(V2*(-G21*sentheta2+B21*costheta2));// criação da derivada de

P2 em função de theta2
var derivP2V2=(G21*costheta2+B21*sentheta2)+2*V2*G22;// criação da derivada
de P2 em função de V2
var derivQ2theta2=(V2*(G21*costheta2+B21*sentheta2));// criação da derivada de
Q2 em função de theta2
var derivQ2V2=(G21*sentheta2-B21*costheta2)-2*V2*B22; );// criação da derivada
de Q2 em função de V2
var inversa=1/((derivP2theta2*derivQ2V2)-(derivP2V2*derivQ2theta2)); //criação de

variável para utilização no método analítico de inversão de matrizes
j) Código para realizar a montagem da Matriz Jacobiana
É necessário a montagem de uma matriz que possuí o apelido de “Matriz de

Sensibilidade” por retratar a variação dos valores de potência em função dos
parâmetros de tensão e ângulo de fase das barras. Esta matriz que é oficialmente
chamada de Jacobiana é feita pelo código descrito a seguir.
var matriz = [
[(a=inversa*derivQ2V2),(b=inversa*(-derivP2V2))], // primeira linha da matriz com
duas colunas, no sistema conta como linha zero
[(c=inversa*(-derivQ2theta2)),(d=inversa*(derivP2theta2))]//segunda linha da
matriz com duas colunas, linha 1
48
k) Código para mecanizar o processo iterativo
Nesta etapa do cálculo o algoritmo executa o processo iterativo, onde este é

processado até que seja encontrado o valor da incógnita em questão, de forma que
esta solucione a equação cujo valor final seja inferior ao erro definido em 0,1%:
var t=theta+(a*deltaP2+b*deltaQ2);
var v=V2+(c*deltaP2+d*deltaQ2);
theta=t;
V2=v;
} while (modulodeltaP2&&modulodeltaQ2 > 0.001);
l) Apresentação do código para a exibição dos resultados
Após a realização de todo processo matemático, o algoritmo exibe o resultado

na Interface WEB de em um formato de alerta. O código a seguir descreve o método
de exibição dos valores das incógnitas encontrados.
var provareal=V2*(G21*costheta2+B21*sentheta2)+V2aoquadrado*G22;
var provareal2=V2*(G21*sentheta2-B21*costheta2)-V2aoquadrado*B22;
alert(theta);
alert(V2);
}
3.2.3 Testes Preliminares para Avaliação do Conjunto de Algoritmos para

Cálculo do Fluxo de Potência
Para a aferição do código para solução de problemas envolvendo fluxo de
potência, foi aplicada uma simulação de uma rede com os componentes exatamente
iguais aos citados anteriormente no capítulo 2 no item 2.6, os parâmetros da rede em
questão foram inseridos na tabela inicial do programa, conforme apresentado na
Figura 8.
49
Figura 8 - Dados do exemplo inseridos na base
Após a inserção dos dados nos respectivos campos indicados na tabela de

interface do usuário, foi realizado o processo lógico e matemático das informações,
para que então gere os resultados das respectivas incógnitas, os mesmos foram
apresentados na Figura 9.
Figura 9 - Resultado do cálculo de teste
Para verificar a assertividade do teste realizado é necessário observar o

resultado encontrado no cálculo realizado no item 2.6 deste trabalho. Onde neste item
é apresentado o valor da encontrado da incógnita em questão da rede analisada.
Assim como o resultado apresentado no Capítulo 2, tem-se o mesmo valor indicado
na Figura 9 em modo de alerta da página web como resultado do cálculo efetuado
pelo algoritmo de teste. Desta forma é possível prosseguir com a evolução do
programa, uma vez que o fluxo matemático está estabelecido de forma correta.
3.3 Desenvolvimento dos Códigos Utilizados para o Cálculo de Fluxo de

Potência Envolvendo Múltiplas Barras
Para o desenvolvimento de lógicas matemáticas para aplicação deste algoritmo
em uma rede com maior número de barras, foram realizadas algumas adaptações no
código já citado, de forma que possam ser inseridos barras e linhas de tipos diferentes
e de quantidades diferentes. Se tratando de problemas envolvendo mais de duas
barras, se faz necessário a montagem de matriz admitância, jacobiana, derivadas e
equações de forma automática. A seguir serão exemplificados os processos de
adaptação do código, contendo as principais linhas para as principais funções do
algoritmo fonte do aplicativo “Power Flow”.
50
a) Código para realizar a inserção de múltiplas barras e linhas
Um algoritmo para um aplicativo com a finalidade de exemplificar o

comportamento do fluxo de potência em uma rede, precisa ser capaz de resolver o
problema envolvendo diversas topologias. Para tal processamento, foi desenvolvido o
código a seguir, que permite ao usuário inserir componentes na rede (barras ou linhas)
e alterar os parâmetros de cada um destes.
function barras_insert()
{
//window.location = 'lista de componentes.html';
db.transaction(barras_insert_db, errorDB, successDB);
}
function barras_insert_db(tx){
var nome = $("#box").val();

var Tipo_de_Barra = $("#tipobar").val();
var P = $("#P").val();// add agr
var Q = $("#Q").val();// add agr
var V = $("#V").val();// add agr
var theta = $("#theta").val();// add agr
var Tipo_de_Componente = $("#tipocomp").val();

var rs = $("#rs").val();
var xs = $("#xs").val();// add agr
var bsh = $("#bsh").val();// add agr
var origem = $("#linhaorig").val();// add agr
var destino = $("#linhadest").val();// add agr
if(Tipo_de_Componente=="Barra")
{
if((Tipo_de_Barra=="PV" && P==="" || V==="")&& (Tipo_de_Barra=="PQ"

&& P==="" || Q==="")){
alert("Preencha Todos os Campos!")
}
else{
tx.executeSql('INSERT INTO barras (nome, Tipo_de_Barra, P, Q, V, theta) VALUES
("'+ nome +'", "'+ Tipo_de_Barra +'", "'+ P +'", "'+ Q +'", "'+ V +'", "'+ theta
+'")');
window.location = 'lista de componentes.html';
}
}
51
if(Tipo_de_Componente=="Linha")
{
if(rs&&xs&&bsh&&origem&&destino !==""){
tx.executeSql('INSERT INTO linhas (nome, rs, xs, bsh, origem, destino) VALUES ("'+
nome +'", "'+ rs +'", "'+ xs +'", "'+ bsh +'", "'+ origem +'", "'+ destino +'")');
window.location = 'lista de componentes.html';
}
else{
alert("Preencha Todos os Campos!")
}
b) Desenvolvimento do banco de dados
Como serão inseridos diversos tipos de elementos da rede em análise,

consequentemente serão gerados diversos dados que posteriormente deverão ser
utilizados no processo matemático do cálculo de fluxo. Desta forma, faz-se necessário
a utilização de um banco de dados offline que permita a alocação destes dados da
rede. Para executar tal função, o software utiliza o “JQUERY” que habilita o uso do
banco de dados denominado “WEBSQL” que é compatível com o Phonegap. Através
do código a seguir descrito, é habilitada a leitura das informações imputadas pelo
udsuário do aplicativo.
function barras_view(){
db.transaction(barras_view_db, errorDB, successDB);
}
function linhas_view(){
db.transaction(linhas_view_db, errorDB, successDB);
function barras_view_db(tx){
tx.executeSql('SELECT * FROM barras', [], barras_view_data, errorDB);
}
function linhas_view_db(tx){
tx.executeSql('SELECT * FROM linhas', [], linhas_view_data, errorDB);
}
function barras_view_data(tx, results){
$("#barras_listagem").empty();
var len = results.rows.length;

52
for (var i=0; i<len; i++){

f(results.rows.item(i).Tipo_de_Barra=="PV"){
$("#barras_listagem").append("<tr class='barras_item_lista'>"+
"<td width='100'><img src='img/Barra.png' class='LT_icon'></td>"+
"<td width='200'><h5 class='título'>Barra&nbsp" +
results.rows.item(i).id + "</h5><h5>" + results.rows.item(i).nome +
"</h5><h5>Tipo:" + results.rows.item(i).Tipo_de_Barra + "</h5><h5>P:" +
results.rows.item(i).P + "&nbspV:" + results.rows.item(i).V + "</h5></td>"+
"<td><input type='button' class='button_del'
onclick='barras_delete(" + results.rows.item(i).id + ")'></td>"+
"<td><input type='button' class='button_edit'
onclick='barras_update(" + results.rows.item(i).id + ")'></td>"+
"<tr>");
}
if(results.rows.item(i).Tipo_de_Barra=="PQ"){
"<td width='200'><h5 class='título'>Barra&nbsp" + results.rows.item(i).id +
"</h5><h5>" + results.rows.item(i).nome + "</h5><h5>Tipo:&nbsp" +
results.rows.item(i).Tipo_de_Barra + "</h5><h5>P:" + results.rows.item(i).P +
"&nbspQ:" + results.rows.item(i).Q + "</h5></td>"+
"<td><input type='button' class='button_del' onclick='barras_delete(" +
results.rows.item(i).id + ")'></td>"+
"<td><input type='button' class='button_edit' onclick='barras_update(" +
"<tr>");
}
if(results.rows.item(i).Tipo_de_Barra=="V0"){
"<td width='200'><h5 class='título'>Barra&nbsp" + results.rows.item(i).id +
"</h5><h5>" + results.rows.item(i).nome + "</h5><h5>Tipo:&nbsp" +
results.rows.item(i).Tipo_de_Barra + "</h5><h5>V:" + results.rows.item(i).V +
"&nbspθ:" + results.rows.item(i).theta + "</h5></td>"+
"<td><input type='button' class='button_del' onclick='barras_delete(" +

"<td><input type='button' class='button_edit' onclick='barras_update(" +
"<tr>");
}
}
}
function linhas_view_data(tx, results){

53
$("#linhas_listagem").empty();
var len1 = results.rows.length;
for (var i=0; i<len1; i++){
$("#linhas_listagem").append("<tr class='linhas_item_lista'>"+
"<td width='100'><img src='img/LT.png' class='LT_icon'></td>"+
"<td width='200'><h5 class='título'>Linha&nbsp" + results.rows.item(i).id1 +
"</h5><h5>" + results.rows.item(i).nome + "</h5><h5>Rs:&nbsp" +
results.rows.item(i).rs + "&nbsp&nbspXs:&nbsp" + results.rows.item(i).xs +
"</h5><h5>Bsh:&nbsp" + results.rows.item(i).bsh + "</h5><h5>Entre
barras&nbsp" + results.rows.item(i).origem + "&nbspe&nbsp" +
results.rows.item(i).destino + "</h5></td>"+
"<td><input type='button' class='button_del' onclick='linhas_delete(" +
results.rows.item(i).id1 + ")'></td>"+
"<td><input type='button' class='button_edit' onclick='linhas_update(" +
results.rows.item(i).id1 + ")'></td>"+
"<tr>");
}
}
c) Código para a criação da matriz admitância automática
Com a existência de diversas barras sendo interligadas por várias linhas de

transmissão, será possível a formação de “n” tipos de topologias de rede, devido a
isso a matriz que representa tal topologia deverá ser formada e alterada
automaticamente em função dos elementos inseridos na rede. Para elaboração da
matriz admitância e sua alteração automática foi desenvolvido o código descrito a
seguir:
var matriz_rs = new Array(qtde_barras);

var matriz_bsh = new Array(qtde_barras);
for (var i = 0; i < qtde_barras; i++)
{
matriz_rs[i] = new Array(qtde_barras);
matriz_bsh[i] = new Array(qtde_barras);
for (var j = 0; j < qtde_barras; j++){
matriz_rs[i][j] = 0;
matriz_bsh[i][j] = 0;
}
}
for (var i = 0; i < qtde_barras; i++)

{
for (var j = 0; j < qtde_barras; j++)
54
{
if(i == qtde_linhas)
{
break;
}
for(var a = 0; a < qtde_linhas; a++)

{
if(((results.rows.item(a).origem-1) == i && (results.rows.item(a).destino-1) == j) ||
((results.rows.item(a).origem-1) == j && (results.rows.item(a).destino-1) == i))
{
matriz_rs[j][i] = math.divide(-
1,math.complex(results.rows.item(a).rs,results.rows.item(a).xs)) ;
matriz_rs[i][j] = math.divide(-
1,math.complex(results.rows.item(a).rs,results.rows.item(a).xs));
matriz_bsh[j][i] = math.complex(0,results.rows.item(a).bsh) ;
matriz_bsh[i][j] = math.complex(0,results.rows.item(a).bsh);
}
}
}
}
var soma_colunas;
var soma_bsh;
for (var coluna = 0; coluna < qtde_barras; coluna++)
{
soma_bsh = 0;
soma_colunas = 0;
for (var linha = 0; linha < qtde_barras; linha++)

{
if(coluna != linha)
{
soma_colunas = math.subtract(soma_colunas,matriz_rs[linha][coluna]);
soma_bsh = math.add(soma_bsh,matriz_bsh[linha][coluna]);
}
}
matriz_rs[coluna][coluna] = math.add(soma_colunas,soma_bsh);
}
const matrizadmitancia = math.matrix()
for(var a=0;a<qtde_barras;a++){
for(var b=0;b<qtde_barras;b++){
matrizadmitancia.subset(math.index(a,b),ObjetoGlobal.matriz_rs[a][b]);
}
}
55
d) Código para a criação das equações de injeção líquida de potência
Estando a matriz admitância formada, o algoritmo deve desenvolver as

equações de injeção líquida de potência de cada uma das barras do sistema em
análise. Conforme citado anteriormente, a quantidade de barras do sistema varia de
acordo com a necessidade do usuário, consequentemente o número de equações
também é variável. Sendo assim, o algoritmo deve ser capaz de identificar a rede por
meio da matriz admitância e formular as equações das barras, com as informações
contidas na matriz automaticamente. Para a criação das equações foi desenvolvido o
código a seguir:
var equação_ativa=0;
var soma_ativa=0;
var numerodeequacoes=0;
var f=0;
var equação_ativa=0;
var equação_reativa=0;
var soma_reativa=0;
if (results.rows.item(a).P !=""){
Valores_de_entrada.subset(math.index(f,0),results.rows.item(a).P);
f++
for(var i = 0;i<qtde_barras; i++){

var Vk= results.rows.item(a).V
var Vm= results.rows.item(i).V
var thetak= results.rows.item(a).theta
var thetam= results.rows.item(i).theta
if(ObjetoGlobal.matriz_rs[a][i] == 0)
{
var Gkm= ObjetoGlobal.matriz_rs[a][i];
var Bkm= ObjetoGlobal.matriz_rs[a][i];
}
else
{
var Gkm= ObjetoGlobal.matriz_rs[a][i].re;
var Bkm= ObjetoGlobal.matriz_rs[a][i].im;
}
if(Vk==="")
56
{
Vk='V'+(a+1)+''
}
if(Vm==="")
{
Vm='V'+(i+1)+''
}
if(thetak==="")
{
thetak='theta'+(a+1)+''
}
if(thetam==="")
{
thetam='theta'+(i+1)+''
}
equação_ativa = math.parse(''+ Vk +'*('+ Vm +'*('+Gkm+'*cos('+thetak+'-
'+thetam+')+'+Bkm+'*sin('+thetak+'-'+thetam+')))')
soma_ativa= math.parse(''+soma_ativa+'+'+equação_ativa+'')
}
}
var simplificaP= math.simplify(soma_ativa)
if(soma_ativa !==0){
equacoes.subset(math.index(numerodeequacoes,0), simplificaP);
numerodeequacoes++
}
soma_ativa = 0
}
if (results.rows.item(a).Q !=""){
Valores_de_entrada.subset(math.index(f,0),results.rows.item(a).Q);
f++
for(var i = 0;i<qtde_barras; i++){

var Vk= results.rows.item(a).V
var Vm= results.rows.item(i).V
var thetak= results.rows.item(a).theta
var thetam= results.rows.item(i).theta
if(ObjetoGlobal.matriz_rs[a][i] == 0)
{
var Gkm= ObjetoGlobal.matriz_rs[a][i];
var Bkm= ObjetoGlobal.matriz_rs[a][i];
}
else
{
57
var Gkm= ObjetoGlobal.matriz_rs[a][i].re;

var Bkm= ObjetoGlobal.matriz_rs[a][i].im;
}
if(Vk==="")
{
Vk='V'+(a+1)+''
}
if(Vm==="")
{
Vm='V'+(i+1)+''
}
if(thetak==="")
{
thetak='theta'+(a+1)+''
}
if(thetam==="")
{
thetam='theta'+(i+1)+''
}
equação_reativa = math.parse(''+ Vk +'*('+ Vm +'*('+Gkm+'*sin('+thetak+'-
'+thetam+')-'+Bkm+'*cos('+thetak+'-'+thetam+')))')
soma_reativa= math.parse(''+soma_reativa+'+'+equação_reativa+'')
}
}
var simplificaQ= math.simplify(soma_reativa)
if(soma_reativa !==0){
equacoes.subset(math.index(numerodeequacoes,0), simplificaQ);
numerodeequacoes++
}
soma_reativa = 0
}
e) Criação do código para operacionalizar o cálculo da derivada das

equações de injeção líquida
Se há a alteração das equações de injeção líquida de potência em função da

topologia de rede, também é variável o número e a formação das derivadas destas,
vale destacar que o algoritmo deve realizar a derivada assim que as equações
estiverem definidas, independentemente da topologia definida pelo usuário do
aplicativo. O código a seguir descreve a lógica para realização das derivadas em
questão.
58
math.derivative(''+equacoes.get([i,0])+'',''+todasincognitas.get([a,0])+'' )
f) Código para a formação da matriz jacobiana
A matriz de sensibilidade, ou matriz jacobiana, é montada a partir das derivadas

das equações de injeção líquida de potência do sistema em análise. Desta forma com
a mudança na topologia de rede, o algoritmo deve ser capaz de alterar a formação da
matriz, de forma a atender o processo de resolução do problema da rede em questão.
Para a formação desta matriz de forma automática foi elaborado o código descrito a
seguir.
const jacobiana = math.matrix()

for (var i = 0; i < numerodeequacoes; i++){
for (var a = 0; a < m1; a++){
jacobiana.subset(math.index(i,a),math.derivative(''+equacoes.get([i,0])+'',''+todasinc
ognitas.get([a,0])+'' ))
}
}
g) Código para funcionalizar o processo iterativo
Com a definição dos elementos citados anteriormente, o algoritmo deve iniciar

o processo de iteração para resolução, identificando o valor das incógnitas das
equações de injeção líquida de potência. Como a rede pode ter várias barras, por
consequência, diversas equações e suas respectivas incógnitas, o processo de
iteração é feito de forma a solucionar o problema respeitando o erro admissível
definido pelo usuário. O código descrito a seguir é responsável pela realização do
processo em questão.
var g=0;
for(var i=0;i<numerodeequacoes;i++){
if(deltaMod.get([i,0])<localStorage.getItem("erromaximo")){
g++
}
}
if(g==numerodeequacoes||numerodeiteraçoes==localStorage.getItem("num_iter")){
if(numerodeiteraçoes==localStorage.getItem("num_iter")){
alert("Limite de iterações atingido.")
if(localStorage.getItem("num_iter")==1){
const submatrizjacob = math.matrix()

59
var preenchejacob = 0
var auxiliar = 0
var n =0
if(n==0){
for (var i = 0; i < numerodeequacoes; i++){
for (var a = 0; a < m1; a++){

preenchejacob=jacobiana.get([i,a])
for(var x=0;x<numerodeequacoes;x++){
auxiliar= math.simplify(''+preenchejacob+'', {[''+todasincognitas.get([x,0])+'']:
valor_das_incognitas.get([x,0]) })
preenchejacob = auxiliar;
}
submatrizjacob.subset(math.index(i,a),math.eval(''+preenchejacob+''))
}
}
const deltathetaV = math.multiply(math.divide(1,submatrizjacob),deltaPQ)
for(var i=0; i<m1; i++){
valor_das_incognitas.subset(math.index(i,0),math.add(valor_das_incognitas,deltathet
aV).get([i,0]))
}
var m2=0
for (var m=0;m<e;m++){
valorestheta.subset(math.index(m,0),valor_das_incognitas.get([m2,0]))
m2++
}
for (m=0;m<d;m++){
valorestensao.subset(math.index(m,0),valor_das_incognitas.get([m2,0]))
m2++
}
}
}
final_das_iteracoes()
}
h) Descrição do código para realizar o cálculo do fluxo de potência
Uma vez que o processo de iteração é finalizado e todas as incógnitas que

solucionam as equações de injeção líquida de potência são identificadas, o algoritmo
realiza o cálculo do fluxo das potências ativa e reativa entre todas as barras que estão
interligadas por meio de linhas de transmissão definidas pelo usuário do aplicativo.
60
Para realização do cálculo do fluxo na rede em questão foi desenvolvido o

código a seguir.
const potenciaativa = math.matrix();

const potenciareativa = math.matrix();
if(matrizadmitancia.get([a,b])!==0 && a!=b){

potenciaativa.subset(math.index(a,b),math.subtract(math.multiply(-
1,valoresfinaistensao.get([a,0]),valoresfinaistensao.get([a,0]),matrizadmitancia.get([
a,b]).re),math.multiply(valoresfinaistensao.get([a,0]),valoresfinaistensao.get([b,0]),m
ath.add(math.multiply(-
1,ObjetoGlobal.matriz_rs[a][b].im,math.sin(math.subtract(valoresfinaistheta.get([a,0
]),valoresfinaistheta.get([b,0])))),math.multiply(-
1,matrizadmitancia.get([a,b]).re,math.cos(math.subtract(valoresfinaistheta.get([a,0]),
valoresfinaistheta.get([b,0]))))))))
potenciareativa.subset(math.index(a,b),math.subtract(math.multiply(-
1,valoresfinaistensao.get([a,0]),valoresfinaistensao.get([a,0]),math.add(math.multiply
(-
1,ObjetoGlobal.matriz_rs[a][b]),ObjetoGlobal.matriz_bsh[a][b]).im),math.multiply(v
aloresfinaistensao.get([a,0]),valoresfinaistensao.get([b,0]),math.add(math.multiply(O
bjetoGlobal.matriz_rs[a][b].im,math.cos(math.subtract(valoresfinaistheta.get([a,0]),v
aloresfinaistheta.get([b,0])))),math.multiply(-
1,matrizadmitancia.get([a,b]).re,math.sin(math.subtract(valoresfinaistheta.get([a,0]),
valoresfinaistheta.get([b,0]))))))))
}
}
}
i) Código para realizar o cálculo do fluxo de perdas nas linhas
Para a análise do fluxo de potência em uma rede, é de grande importância a

determinação do valor de perdas nas linhas de transmissão, uma vez que isto permite
a identificação de possíveis problemas na rede e/ou planejar modificações para
melhorar a eficiência da transmissão. O cálculo em questão é realizado pelo seguinte
código:
const perdaativa = math.matrix()

const perdareativa = math.matrix()
if(a!=b){
perdaativa.subset(math.index(a,b),math.add(potenciaativa.get([a,b]),potenciaativa.ge
t([b,a])))
61
perdareativa.subset(math.index(a,b),math.add(potenciareativa.get([a,b]),potenciareat
iva.get([b,a])))
}
}
}
3.4 Conclusões parciais

As principais conclusões do capítulo em questão, foram apresentadas nos itens
descritos a seguir:
• Os estudos preliminares com relação a identificação das necessidades básicas

do aplicativo e do algoritmo responsável pelo cálculo, foram providenciais para
um bom desenvolvimento do mesmo;
• As linguagens de programação forneceram grandes facilidades com suas
bibliotecas que possuem funções lógicas e matemáticas pré-definidas;
• A escolha da interface WEB para realização do desenvolvimento do programa
de teste e do programa completo proporcionou uma visualização simplificada
dos resultados e das funções exercidas pelo algoritmo responsável pela
realização dos cálculos;
• A determinação de um fluxograma que pautou o desenvolvimento do algoritmo
de teste, bem como o algoritmo completo, também facilitou a elaboração e o
entendimento de todo o processo, de forma que cada ação desenvolvida no
código respeitava um fluxo de informações pré-definidas pelo grupo;
• Diante das evidências anteriormente citadas, o processo de implementação do
algoritmo para soluções de problemas envolvendo o fluxo de potência em redes
com duas barras foi realizado com sucesso.
62
CAPÍTULO 4 – AVALIAÇÃO DA PRECISÃO DO CONJUNTO DE

ALGORITMOS PARA CÁLCULO DO FLUXO DE POTÊNCIA
No quarto capítulo são apresentados os testes realizados para aferir a precisão dos
resultados obtidos do aplicativo desenvolvido. Vale destacar que, foi utilizado como
base na comparação o programa ANAREDE.
4.1 Metodologia Utilizada nos Testes da Avaliação do Sistema

Para garantir a confiabilidade do aplicativo Power Flow, foram realizados testes
com outro programa, cujo nome é ANAREDE (Análise de Redes Elétricas) e é
amplamente utilizado no setor elétrico brasileiro.
Os testes foram realizados com quatro sistemas elétricos padrões, definidos

pelo IEEE, sendo estes denominados por 3, 5, 9 e 14 barras. Em seguida, foram
comparados os resultados de ambos os softwares e calculado, através da equação
(4.1), a margem de erro dos resultados do Power Flow em relação aos do ANAREDE,
afim de analisar a precisão do aplicativo desenvolvido.
𝑅𝑒𝑠𝑢𝑙𝑡𝑎𝑑𝑜𝐴𝑁𝐴𝑅𝐸𝐷𝐸 −𝑅𝑒𝑠𝑢𝑙𝑡𝑎𝑑𝑜𝑃𝑜𝑤𝑒𝑟 𝐹𝑙𝑜𝑤

𝜀(%) = ( ) × 100% (4.1)
𝑅𝑒𝑠𝑢𝑙𝑡𝑎𝑑𝑜𝐴𝑁𝐴𝑅𝐸𝐷𝐸
4.2 Descrição dos Testes da Avaliação do Sistema

Para a realização dos testes, foram inseridos todos os componentes dentro de
ambos os programas, especificando os tipos e os parâmetros das barras, assim como
as impedâncias equivalentes das linhas, conforme modelos do IEEE. Os resultados
foram apresentados em tabelas comparativas para facilitar a compreensão e análise
dos mesmos.
4.2.1 Resultados do Teste com Sistema Elétrico com 3 Barras

O primeiro teste comparativo foi realizado em um sistema elétrico com 3 barras.
No qual primeiramente são apresentados os parâmetros das barras e os dados de
impedância, após isto, são expostos os resultados e, por fim, analisados os erros
obtidos.
63
a) Características do sistema elétrico
Na Tabela 3 são apresentados os tipos de cada uma das 3 barras assim como
seus respectivos parâmetros. E, na Tabela 4 são expostos os dados de impedância.
Ambas as tabelas possuem as informações essenciais para que seja possível calcular
o fluxo de potência do sistema.
Tabela 3 – Parâmetros de rede do sistema elétrico de 3 barras
PARÂMETROS DAS BARRAS

NÚMERO TIPO P (p.u.) Q (p.u.) V (p.u.) Θ (rad)
1 Vθ - - 1 0
2 PQ - 0,057 - 0,027 - -
3 PV - 0,157 - 0,98 -
Tabela 4 – Dados de impedância (em p.u.) das linhas do sistema elétrico com 3 barras
DADOS DE IMPEDÂNCIA DAS LINHAS

NÚMERO ORIGEM DESTINO Rs xs Bsh
LINHA 1 1 2 0,1 1,09 0,01
LINHA 2 2 3 0,2 2,09 0,02
LINHA 3 3 1 0,1 1,09 0,01
b) Resultados obtidos
Inserindo os dados das tabelas anteriores nos dois programas (ANAREDE e

Power Flow) foram obtidos os resultados das incógnitas de tensão (módulos e
ângulos) expostos na Tabela 5.
Tabela 5 - Valores das incógnitas calculados, assim como seus erros percentuais, no Power Flow e
no ANAREDE para o sistema elétrico de 3 barras
VALORES DAS INCÓGNITAS

INCÓGNITAS Power Flow Calc ANAREDE Erro (%)
Radianos Graus Graus
θ2 -0,092 -5,2 -5,2 0,0%
θ3 -0,147 -8,4 -8,4 0,0%
V2 0,988 (p.u.) 0,988 (p.u.) 0,0%
64
Em seguida, com as incógnitas calculadas, é possível realizar o cálculo dos

fluxos de potência. Na tabela 6 são apresentados os resultados dos fluxos de potência
e das perdas, obtidos pelo ANAREDE e pelo Power Flow respectivamente. Na
sequência, são apresentados os erros percentuais entre os resultados dos dois
programas, na respectiva ordem.
Tabela 6 – Fluxos e perdas calculados (em p.u.) pelo ANAREDE e pelo Power Flow para o sistema
elétrico de 3 barras e os erros percentuais entre os dois programas
ANAREDE Power Flow Calc Erro (%)

LINHAS
FLUXO PERDAS FLUXO PERDAS FLUXO PERDAS
Origem Destino MW MVAr MW MVAr MW MVAr MW MVAr MW MVAr MW MVAr
1 2 8,4 -0,3 0,07 -1,21 8,35 -0,27 0,07 -1,21 0,0% 0,0% 0,0% 0,0%
1 3 13,3 0,6 0,18 0 13,31 0,58 0,18 0,00 0,0% 0,0% 0,0% 0,0%
2 1 -8,3 -0,9 0,07 -1,21 -8,28 -0,94 0,07 -1,21 0,0% 0,0% 0,0% 0,0%
2 3 2,6 -1,8 0,01 -3,72 2,58 -1,76 0,014 -3,73 0,0% 0,0% 0,0% 0,0%
3 1 -13,1 -0,6 0,18 0 -13,13 -0,59 0,18 0,00 0,0% 0,0% 0,0% 0,0%
3 2 -2,6 -2 0,01 -3,73 -2,57 -1,97 0,014 -3,73 0,0% 0,0% 0,0% 0,0%
c) Análise dos resultados obtidos
Analisando os resultados apresentados nas Tabelas 5 e 6, é possível concluir

que para um sistema elétrico de 3 barras, o aplicativo desenvolvido foi eficiente, pois
apresentou 0% de erro no cálculo de todos os fluxos de potência nas linhas de
transmissão, assim como nas estimativas de perdas e dos valores das tensões.

O segundo teste comparativo foi realizado em um sistema elétrico com 5
barras. Seguindo a mesma metodologia, primeiramente são apresentados os
parâmetros das barras e os dados de impedância, após isto, são expostos os
resultados e, por fim, analisados os erros obtidos.
Nas Tabelas 8 e 9 são apresentados os tipos de cada uma das 5 barras, assim
como seus respectivos parâmetros e os dados de impedância do sistema utilizado.
65
Tabela 7 - Parâmetros de rede do sistema elétrico de 5 barras

BARRA 1 Vθ - - 1 0
BARRA 2 PV 0,183 - 1,045 -
BARRA 3 PV -0,943 - 1,01 -
BARRA 4 PQ -0,478 -0,039 - -
BARRA 5 PQ -0,076 -0,016 - -
Tabela 8 - Dados de impedância (em p.u.) das linhas do sistema elétrico com 5 barras

NÚMERO ORIGEM DESTINO rs Xs Bsh
LINHA 1 1 2 0,01938 0,05917 0,02
LINHA 2 1 5 0,05403 0,22304 0,053
LINHA 3 2 3 0,04699 0,19797 0,07
LINHA 4 2 4 0,05811 0,17632 0,041
LINHA 5 2 5 0,05695 0,17388 0,06
LINHA 6 3 4 0,06701 0,17103 0,075
LINHA 7 4 5 0,01335 0,04211 0,0584
Na Tabela 9, além das incógnitas de tensões e ângulos calculadas, também é

apresentada a margem de erro entre os resultados obtidos pelos programas
ANAREDE e o Power Flow.
Tabela 9 - Valores das incógnitas encontrados no Power Flow e no ANAREDE, assim como os erros
percentuais, para o sistema elétrico de 5 barras
VALORES DAS INCÓGNITAS

θ2 -0,0740 -4,3 -4,3 0,0%
θ3 -0,1860 -10,6 -10,6 0,0%
θ4 -0,1270 -7,3 -7,3 0,0%
θ5 -0,1040 -6,0 -6,0 0,0%
V4 1,031 (p.u.) 1,031 (p.u.) 0,0%
V5 1,033 (p.u.) 1,033 (p.u.) 0,0%
66
Em seguida, com as incógnitas definidas, é possível realizar o cálculo dos

fluxos de potência. Na Tabela 10 são apresentados os resultados dos fluxos de
potência e das perdas, obtidos pelo ANAREDE e pelo Power Flow, respectivamente.
Na sequência, são apresentados os erros percentuais entre os resultados dos dois
Tabela 10 - Fluxos calculados (em p.u.) pelo ANAREDE e pelo Power Flow para o sistema elétrico de
5 barras e os erros percentuais entre os dois programas

LINHAS
Origem Destino MW MVAr MW MVar MW MVar MW MVAr MW MVar MW MVAr
1 2 97,3 -105 3,89 7,7 97,3 -105 3,89 7,70 0,0% 0,0% 0,0% 0,0%
1 5 42,8 -28,1 1,27 -5,72 42,8 -28,1 1,27 -5,72 0,0% 0,0% 0,0% 0,0%
2 1 -93,4 112,7 3,89 7,7 -93,4 112,7 3,89 7,70 0,0% 0,0% 0,0% 0,0%
2 3 61 -0,3 1,62 -7,95 61 -0,3 1,62 -7,95 0,0% 0,0% 0,0% 0,0%
2 4 31,6 -5,8 0,53 -7,22 31,6 -5,8 0,53 -7,22 0,0% 0,0% 0,0% 0,0%
2 5 19,1 -5,5 0,19 -12,37 19,1 -5,5 0,19 -12,38 0,0% 0,0% 0,0% 0,0%
3 2 -59,4 -7,6 1,62 -7,95 -59,4 -7,6 1,62 -7,95 0,0% 0,0% 0,0% 0,0%
3 4 -34,9 -5,4 0,81 -13,57 -34,9 -5,4 0,81 -13,57 0,0% 0,0% 0,0% 0,0%
4 2 -31,1 -1,4 0,53 -7,22 -31,1 -1,4 0,53 -7,22 0,0% 0,0% 0,0% 0,0%
4 3 35,7 -8,2 0,81 -13,57 35,7 -8,2 0,81 -13,57 0,0% 0,0% 0,0% 0,0%
4 5 -52,5 5,7 0,36 -11,3 -52,5 5,7 0,36 -11,30 0,0% 0,0% 0,0% 0,0%
5 1 -41,5 22,3 1,27 -5,72 -41,5 22,3 1,27 -5,72 0,0% 0,0% 0,0% 0,0%
5 2 -18,9 -6,9 0,19 -12,37 -18,9 -6,9 0,19 -12,38 0,0% 0,0% 0,0% -0,1%
5 4 52,8 -17 0,36 -11,3 52,8 -17 0,36 -11,30 0,0% 0,0% 0,0% 0,0%
Analisando a Tabela 10 é possível concluir que, para um sistema elétrico de 5

barras, o aplicativo desenvolvido foi eficiente, pois apresentou baixo erro percentual
em relação ao ANAREDE, vale destacar que, tais variações podem ter sido
ocasionadas pelas diferenças entre as estruturas dos programas (não foi possível
realizar o levantamento da estrutura referente ao ANAREDE, porém, acredita-se que
o aplicativo desenvolvido neste trabalho possua uma composição consideravelmente
mais simples).
67

O terceiro teste comparativo foi realizado em um sistema elétrico com 9 barras.
Seguindo a mesma metodologia, primeiramente são apresentados os parâmetros das
barras e os dados de impedância, após isto, são expostos os resultados e, por fim,
analisados os erros obtidos.
Nas Tabelas 11 e 12 são apresentados os tipos de cada uma das 9 barras,

assim como seus respectivos parâmetros e os dados de impedância do sistema
utilizado, respectivamente.

BARRA 1 Vθ - - 1 0
BARRA 2 PV 0,183 - 1,045 -
BARRA 3 PV -0,943 - 1,01 -
BARRA 4 PQ -0,478 -0,039 - -
BARRA 5 PQ -0,076 -0,016 - -
BARRA 6 PV -0,112 - 1,07 -
BARRA 7 PQ -0,056 0,008 - -
BARRA 8 PV 0,0003 - 1,09 -
BARRA 9 PQ -0,295 -0,166 - -

LINHA 1 1 2 0,01938 0,05917 0,02
LINHA 2 1 5 0,05403 0,22304 0,053
LINHA 3 2 3 0,04699 0,19797 0,07
LINHA 4 2 4 0,05811 0,17632 0,041
LINHA 5 2 5 0,05695 0,17388 0,06
LINHA 6 3 4 0,06701 0,17103 0,075
LINHA 7 4 5 0,01335 0,04211 0,0584
LINHA 8 7 8 0,0054 0,17615 0,0598
LINHA 9 7 9 0,0438 0,11001 0,02
68

LINHA 10 5 6 0,375 0,25202 0,022
LINHA 11 4 7 0,0732 0,20912 0,033
Nas Tabelas 13 e 14, além das incógnitas de ângulos e tensões,

respectivamente, calculadas, também são apresentados a margem de erro entre os
resultados obtidos pelo ANAREDE e o Power Flow.
Tabela 13 - Valores dos ângulos de defasagem calculados no Power Flow e no ANAREDE, assim
como os erros percentuais, para o sistema elétrico de 9 barras
VALORES CALCULADOS
θ2 -0,096068 -5,5 -5,5 0,0%
θ3 -0,220207 -12,6 -12,6 0,0%
θ4 -0,17842 -10,2 -10,2 0,0%
θ5 -0,150939 -8,6 -8,6 0,0%
θ6 -0,274925 -15,7 -15,7 0,0%
θ7 -0,259157 -14,8 -14,8 0,0%
θ8 -0,260172 -14,9 -14,9 0,0%
θ9 -0,283331 -16,2 -16,2 0,0%
Tabela 14 - Valores das tensões (em p.u.) calculadas no Power Flow e no ANAREDE, assim como os
respectivos erros percentuais, para o sistema elétrico de 9 barras
VALORES CALCULADOS
INCÓGNITAS Erro (%)
Power Flow Calc ANAREDE
V4 1,043 1,043 0,0%
V5 1,048 1,048 0,0%
V7 1,054 1,054 0,0%
V9 1,025 1,025 0,0%
Em seguida, com as incógnitas definidas, é possível realizar o cálculo dos

fluxos de potência. Na tabela 15 são apresentados os resultados dos fluxos de
potência e das perdas, obtidos pelo ANAREDE e pelo Power Flow respectivamente.
69
Na sequência, são apresentados os erros percentuais entre os resultados dos dois

9 barras e os erros percentuais entre os dois programas

LINHAS
Origem Destino MW MVAr MW MVar MW MVAr MW MVAr MW MVAr MW MVAr
1 2 132,85 -113,43 5,83 13,61 132,91 -113,4 5,83 13,62 0,0% 0,0% 0,0% 0,0%
1 5 63,01 -36,72 2,68 -0,06 63,04 -36,7 2,68 -0,06 0,0% 0,0% 0,0% 6,7%
2 1 -127,02 127,03 5,83 13,61 -127,08 127,0 5,83 13,62 0,0% 0,0% 0,0% 0,0%
2 3 67,56 -1,1 1,98 -6,43 67,56 -1,1 1,98 -6,43 0,0% -0,4% 0,0% 0,0%
2 4 46,84 -16,57 1,25 -5,16 46,86 -16,6 1,25 -5,16 0,0% 0,0% 0,0% 0,1%
2 5 30,93 -17,5 0,56 -11,43 30,95 -17,5 0,56 -11,42 -0,1% 0,0% 0,0% 0,0%
3 2 -65,57 -5,33 1,98 -6,43 -65,58 -5,3 1,98 -6,43 0,0% 0,0% 0,0% 0,0%
3 4 -28,72 -15,28 0,58 -14,33 -28,72 -15,3 0,58 -14,33 0,0% 0,0% 0,0% 0,0%
4 2 -45,6 11,41 1,25 -5,16 -45,6 11,4 1,25 -5,16 0,0% -0,1% 0,0% 0,1%
4 3 29,3 0,96 0,58 -14,33 29,3 0,9 0,58 -14,33 0,0% 0,6% 0,0% 0,0%
4 5 -68,14 3,74 0,58 -10,93 -68,12 3,7 0,58 -10,93 0,0% 0,3% 0,0% 0,0%
4 7 36,63 -20 1,08 -4,15 36,63 -20,0 1,08 -4,15 0,0% 0,0% 0,0% -0,1%
5 1 -60,33 36,65 2,68 -0,06 -60,36 36,7 2,68 -0,06 0,0% 0,0% 0,0% 6,7%
5 2 -30,37 6,07 0,56 -11,43 -30,39 6,1 0,56 -11,42 -0,1% -0,1% 0,0% 0,0%
5 4 68,72 -14,67 0,58 -10,93 68,7 -14,6 0,58 -10,93 0,0% 0,1% 0,0% 0,0%
5 6 14,41 -29,63 3,24 -2,76 14,45 -29,72 3,25 -2,75 -0,3% -0,2% -0,3% 0,4%
6 5 -11,17 26,88 3,24 -2,76 -11,2 26,9 3,25 -2,75 -0,3% -0,2% -0,3% 0,4%
7 4 -35,55 15,85 1,08 -4,15 -35,54 15,8 1,08 -4,15 0,0% 0,0% 0,0% -0,1%
7 8 -0,01 -28,45 0,02 -12,99 -0,01 -28,4 0,02 -12,99 0,0% 0,0% 0,0% 0,0%
7 9 29,95 13,41 0,45 -3,19 29,95 13,4 0,45 -3,19 0,0% 0,0% 0,0% 0,0%
8 7 0,03 15,47 0,02 -12,99 0,03 15,5 0,02 -12,99 0,0% 0,0% 0,0% 0,0%
9 7 -29,5 -16,6 0,45 -3,19 -29,5 -16,6 0,45 -3,19 0,0% 0,0% 0,0% 0,0%
Analisando a Tabela 15, é possível concluir que para um sistema elétrico de 9

barras, o aplicativo desenvolvido foi considerado eficiente, pois apresentou baixos
erros percentuais em relação ao ANAREDE, afetando apenas na precisão de décimos
e centésimos. De forma análoga ao item anterior, tais variações podem ter sido
ocasionadas pelas diferenças entre as estruturas dos programas.
70

O quarto e último teste comparativo foi realizado em um sistema elétrico com
14 barras. Seguindo a mesma metodologia, primeiramente são apresentados os
parâmetros das barras e os dados de impedância, após isto, são expostos os
resultados e, por fim, analisados os erros obtidos.

Na Tabela 16 são apresentados os tipos de cada uma das 14 barras assim
como seus respectivos parâmetros. E, na Tabela 17 são expostos os dados de
impedância.

BARRA 1 Vθ - - 1 0
BARRA 2 PV 0,183 - 1,045 -
BARRA 3 PV -0,943 - 1,01 -
BARRA 4 PQ -0,478 -0,039 - -
BARRA 5 PQ -0,076 -0,016 - -
BARRA 6 PV -0,112 - 1,07 -
BARRA 7 PQ -0,056 0,008 - -
BARRA 8 PV 0,0003 - 1,09 -
BARRA 9 PQ -0,295 -0,166 - -
BARRA 10 PQ -0,09 -0,058 - -
BARRA 11 PQ -0,035 -0,018 - -
BARRA 12 PQ -0,061 -0,018 - -
BARRA 13 PQ -0,135 -0,058 - -
BARRA 14 PQ -0,149 -0,05 - -

NÚMERO ORIGEM DESTINO Rs Xs Bsh
LINHA 1 1 2 0,01938 0,05917 0
LINHA 2 1 5 0,05403 0,22304 0
LINHA 3 2 3 0,04699 0,19797 0
LINHA 4 2 4 0,05811 0,17632 0
71

NÚMERO ORIGEM DESTINO Rs Xs Bsh
LINHA 5 2 5 0,05695 0,17388 0
LINHA 6 3 4 0,06701 0,17103 0
LINHA 7 4 5 0,01335 0,04211 0
LINHA 8 6 11 0,09498 0,1989 0
LINHA 9 6 12 0,12291 0,25581 0
LINHA 10 6 13 0,06615 0,13027 0
LINHA 11 7 8 0,0054 0,17615 0
LINHA 12 7 9 0,0438 0,11001 0
LINHA 13 9 10 0,03181 0,0845 0
LINHA 14 9 14 0,12711 0,27038 0
LINHA 15 10 11 0,08205 0,19207 0
LINHA 16 12 13 0,22092 0,19988 0
LINHA 17 13 14 0,17093 0,34802 0
LINHA 18 5 6 0,375 0,25202 0
LINHA 19 4 7 0,0732 0,20912 0
Nas Tabelas 18 e 19, além das incógnitas de ângulos e tensões,

respectivamente, calculadas, também são apresentadas as margens de erro entre os
resultados obtidos pelo ANAREDE e o Power Flow.
Tabela 18 - Valores dos ângulos de defasagem calculados no Power Flow e no ANAREDE, assim
como os erros percentuais, para o sistema elétrico de 14 barras
VALORES CALCULADOS
θ2 -0,128174 -7,3 -7,3 0,0%
θ3 -0,272558 -15,6 -15,6 0,0%
θ4 -0,242407 -13,9 -13,9 0,0%
θ5 -0,211923 -12,1 -12,1 0,0%
θ6 -0,543664 -31,2 -31,2 0,0%
θ7 -0,404911 -23,2 -23,2 0,0%
θ8 -0,406651 -23,3 -23,3 0,0%
θ9 -0,472562 -27,1 -27,1 0,0%
θ10 -0,490465 -28,1 -28,1 0,0%
θ11 -0,51897 -29,7 -29,7 0,0%
72
VALORES CALCULADOS
θ12 -0,553662 -31,7 -31,7 0,0%
θ13 -0,548545 -31,4 -31,4 0,0%
θ14 -0,524864 -30,1 -30,1 0,0%
Tabela 19 - Valores das tensões (em p.u.) calculadas no Power Flow e no ANAREDE, assim como os
respectivos erros percentuais, para o sistema elétrico de 14 barras
VALORES CALCULADOS Erro

INCÓGNITAS
Power Flow Calc ANAREDE (%)
V4 1,026 1,026 0,0%

V5 1,036 1,036 0,0%
V7 1,030 1,030 0,0%
V9 1,002 1,002 0,0%
V10 1,007 1,007 0,0%
V11 1,034 1,034 0,0%
V12 1,050 1,050 0,0%
V13 1,043 1,043 0,0%
V14 1,001 1,001 0,0%
Na Tabela 20 são apresentados os resultados dos fluxos de potência e das

perdas, obtidos pelo ANAREDE e pelo Power Flow respectivamente. Na sequência,
são apresentados os erros percentuais entre os resultados dos dois programas, na
respectiva ordem.
14 barras e os erros entre os dois programas

LINHAS
1 2 185,67 -122,38 9,58 29,26 185,67 -122,38 9,58 29,26 0,0% 0,0% 0,0% 0,0%
1 5 90,97 -27,72 4,89 20,17 90,97 -27,72 4,89 20,17 0,0% 0,0% 0,0% 0,0%
2 1 -176,09 151,64 9,58 29,26 -176,08 151,64 9,58 29,26 0,0% 0,0% 0,0% 0,0%
2 3 78,02 5,5 2,63 11,09 78,02 5,50 2,63 11,09 0,0% 0,0% 0,0% 0,0%
2 4 67,07 -6,79 2,42 7,34 67,07 -6,78 2,42 7,34 0,0% 0,1% 0,0% 0,0%
2 5 49,3 -8,47 1,31 3,98 49,3 -8,47 1,30 3,98 0,0% 0,0% 0,8% 0,0%
73

LINHAS
3 2 -75,38 5,58 2,63 11,09 -75,38 5,58 2,63 11,09 0,0% 0,0% 0,0% 0,0%
3 4 -18,92 -1,67 0,24 0,6 -18,92 -1,67 0,24 0,60 0,0% 0,0% 0,0% 0,0%
4 2 -64,65 14,12 2,42 7,34 -64,65 14,12 2,42 7,34 0,0% 0,0% 0,0% 0,0%
4 3 19,15 2,27 0,24 0,6 19,15 2,27 0,24 0,60 0,0% 0,0% 0,0% 0,0%
4 5 -76,57 1,07 0,74 2,35 -76,57 1,07 0,74 2,35 0,0% 0,0% 0,0% 0,0%
4 7 74,27 -21,36 4,15 11,87 74,27 -21,36 4,15 11,87 0,0% 0,0% 0,0% 0,0%
5 1 -86,09 47,89 4,89 20,17 -86,08 47,89 4,89 20,17 0,0% 0,0% 0,0% 0,0%
5 2 -48 12,45 1,31 3,98 -48 12,45 1,30 3,98 0,0% 0,0% 0,8% 0,0%
5 4 77,32 1,28 0,74 2,35 77,32 1,28 0,74 2,35 0,0% 0,0% 0,0% 0,0%
5 6 49,17 -63,22 22,42 15,07 49,17 -63,22 22,42 15,06 0,0% 0,0% 0,0% 0,1%
6 5 -26,75 78,29 22,42 15,07 -26,75 78,28 22,42 15,06 0,0% 0,0% 0,0% 0,1%
6 11 -3,68 21,07 0,38 0,79 -3,68 21,07 0,38 0,80 0,0% 0,0% 0,0% -1,3%
6 12 6,84 5,1 0,08 0,16 6,84 5,10 0,08 0,16 0,0% 0,0% 0,0% 0,0%
6 13 12,39 16,17 0,24 0,47 12,39 16,17 0,24 0,47 0,0% 0,0% 0,0% 0,0%
7 4 -70,11 33,23 4,15 11,87 -70,11 33,23 4,15 11,87 0,0% 0,0% 0,0% 0,0%
7 8 0,03 -35,1 0,06 2,05 0,03 -35,10 0,06 2,05 0,0% 0,0% 0,0% 0,0%
7 9 64,48 2,67 1,72 4,32 64,48 2,68 1,72 4,32 0,0% -0,4% 0,0% 0,0%
8 7 0,03 37,15 0,06 2,05 0,03 37,15 0,06 2,05 0,0% 0,0% 0,0% 0,0%
9 7 -62,76 1,64 1,72 4,32 -62,76 1,64 1,72 4,32 0,0% 0,0% 0,0% 0,0%
9 10 17 -11,6 0,13 0,36 17 -11,60 0,13 0,36 0,0% 0,0% 0,0% 0,0%
9 14 16,26 -6,64 0,39 0,83 16,26 -6,64 0,39 0,83 0,0% 0,0% 0,0% 0,0%
10 9 -16,86 11,96 0,13 0,36 -16,86 11,96 0,13 0,36 0,0% 0,0% 0,0% 0,0%
10 11 7,87 -17,76 0,31 0,72 7,86 -17,76 0,30 0,72 0,1% 0,0% 3,2% 0,0%
11 6 4,06 -20,27 0,38 0,79 4,06 -20,27 0,38 0,80 0,0% 0,0% 0,0% -1,3%
11 10 -7,56 18,47 0,31 0,72 -7,56 18,47 0,30 0,72 0,0% 0,0% 3,2% 0,0%
12 6 -6,76 -4,94 0,08 0,16 -6,76 -4,94 0,08 0,16 0,0% 0,0% 0,0% 0,0%
12 13 0,66 3,14 0,02 0,02 0,66 3,14 0,02 0,02 0,0% 0,0% 0,0% 0,0%
13 6 -12,15 -15,7 0,24 0,47 -12,15 -15,70 0,24 0,47 0,0% 0,0% 0,0% 0,0%
13 12 -0,64 -3,12 0,02 0,02 -0,64 -3,12 0,02 0,02 0,0% 0,0% 0,0% 0,0%
13 14 -0,71 13,02 0,27 0,54 -0,7 13,02 0,27 0,54 1,4% 0,0% 0,0% 0,0%
14 9 -15,87 7,47 0,39 0,83 -15,87 7,47 0,39 0,83 0,0% 0,0% 0,0% 0,0%
14 13 0,97 -12,47 0,27 0,54 0,97 -12,47 0,27 0,54 0,0% 0,0% 0,0% 0,0%
Analisando a Tabela 20, nota-se a presença de pequenos erros na comparação

dos dois programas, causados apenas por conta da precisão de décimos e
centésimos. De forma análoga ao item anterior, tais variações podem ter sido
ocasionadas pelas diferenças entre as estruturas dos programas.
74
4.3 Conclusões Parciais do Capítulo

As principais conclusões obtidas neste capítulo foram apresentadas nos itens
descritos a seguir:
• Apesar de ter apresentado algumas divergências nos resultados com baixos

valores de fluxos de potência ou perdas em alguns sistemas elétricos, o
aplicativo atende ao objetivo por ser voltado para estudos e fins educacionais,
visto que possibilita demonstrar as relações proporções e de topologia de rede
e alcançar resultados bem assertivos mais rapidamente do que os cálculos
manuais que é a atual forma utilizada para calcular e avaliar tais fenômenos
dos fluxos de potência;
• Os erros percentuais dos resultados dos testes comparativos entre o aplicativo
desenvolvido e o programa ANAREDE ocorrem por conta das diferenças entre
as estruturas dos mesmos;
• Por fim, analisando todos os testes, pode-se concluir que o aplicativo Power
Flow atinge a sua finalidade de calcular os fluxos de potência e perdas de
sistemas elétricos de pequeno a grande porte, pois obtém resultados efetivos
e compatíveis com o programa ANAREDE, possibilitando as análises didáticas
em sala de aula de maneira mais efetiva do que calculando manualmente.
75
CAPÍTULO 5 – DESENVOLVIMENTO DA IHM DO APLICATIVO

Neste presente capítulo foi explorado o desenvolvimento da IHM do aplicativo,
começando pelas necessidades do usuário e a definição da plataforma de
implementação. Na sequência, o fluxograma, os códigos fonte e o funcionamento que
compõe o item de desenvolvimento. Para terminar, é abordado o processo de
integração com a parte matemática, os testes de desempenho e dos usuários.
5.1 Levantamento das Necessidades Básicas do Usuário

O software foi desenvolvido com base nas diretrizes do Prof. Dr. Alexandre
Rocco, titular da disciplina de Sistema de Potência II e coordenador do curso de
Engenharia Elétrica da Universidade Santa Cecília.
Segundo ele, a necessidade era de ter uma ferramenta que mostrasse a

alteração do fluxo conforme a topologia de rede e os parâmetros dos seus elementos.
Este processo se daria com a inserção de barras em uma rede já resolvida e que
pudesse também confirmar os resultados obtidos no cálculo. Tudo isso feito de forma
simples e rápida por meio de uma interface amigável, e, o mais importante, com
resultados precisos e confiáveis.
A rede deve ser composta por barras e linhas de transmissão com opção de
colocar valores de resistência, reatância indutiva e capacitores shunt. Os resultados
deveriam ser apresentados em forma de tabela com os fluxos entre barras, perdas
nas linhas, módulo de tensão e ângulo de fase das barras; e, os valores de entrada e
os resultados obtidos teriam que ser expressos em p.u.. Estas foram a necessidades
apontadas para o projeto e que nortearam o desenvolvimento da interface.
5.2 Definição da Plataforma para o Desenvolvimento da IHM

Como a finalidade do programa é que seja acessível a grande parte dos alunos,
para tanto, foi optado por utilizar um framework para desenvolvimento em
multiplataforma de celulares. Porém, nesta primeira versão foi desenvolvido, apenas,
para o sistema operacional Android.
76
Atendendo a estes requisitos, foi escolhido o framework denominado de

Phonegap, conforme os próprios desenvolvedores afirmam que:
Utilize suas habilidades existentes de desenvolvimento Web para

rapidamente criar aplicativos híbridos com HTML, CSS e JavaScript. Crie
experiências para várias plataformas com um único código fonte para
alcançar seu público alvo, independentemente do dispositivo. (Phonegap,
2016).
Esta plataforma utiliza a linguagem WEB que é baseada em camadas (HTML,

CSS e JavaScript), ou seja, no mínimo três páginas de códigos, sendo que cada uma
possui uma função na implementação da IHM:
• HTML (Hyper Text Markup Language): define a estrutura da página, ou seja, o

layout que será exibido no navegador ou aplicativo;
• CSS (Cascating Style Sheets): define o estilo, ou seja, a formatação da
estrutura estática montada pelo HTML, dando a caracterização de acordo com
o tema buscado, tornando a interface mais harmoniosa;
• JavaScript: é responsável por dinamizar a estrutura, proporcionando interações
com o usuário, animações no template e tornando a aplicação funcional.
5.3 Definições Iniciais para o Desenvolvimento da IHM

Para o desenvolvimento do aplicativo e da sua IHM foi necessário uma série de
planejamentos antes de se iniciar a implantação de qualquer lógica de programação.
Esta etapa teve como ponto inicial o levantamento das necessidades do usuário e
definição da plataforma, para então construir um fluxograma que oriente os dados e a
disposição da interação entre o aplicativo e o usuário. A partir da construção do
mesmo, foi possível desenvolver a programação lógica da interface gráfica para
interação do usuário com o sistema, de forma que todos os processos ocorram com
harmonia e sem erros.
Por se tratar de um sistema com algumas variações de número de barras,

grandezas elétricas e topologia de rede, faz-se necessário a construção de um
fluxograma para orientar os passos e tomadas de decisões a serem feitas tanto pelo
usuário, quanto pelo próprio algoritmo. A Figura 10, mostra o fluxograma
representativo do aplicativo, onde se observa que após a etapa “INÍCIO” as demais,
subsequentes, na cor laranja, são realizadas pelo usuário. Primeiro deve-se
77
determinar a quantidade e o tipo das barras, além dos valores das grandezas elétricas
de cada uma de acordo com seu tipo (potência ativa, reativa, módulo da tensão, etc.)
em p.u.. Depois, determina-se a topologia da rede com as impedâncias das linhas de
transmissão (onde pode-se incluir os capacitores shunt para linhas que seguem o
modelo pi) também em p.u.. Por fim, deve-se ajustar o número máximo de iterações,
o erro admitido e a potência de base do sistema. A partir da determinação dos
parâmetros anteriormente citados, o aplicativo define as incógnitas que serão
calculadas e a metodologia para a solução do problema.
1 INÍCIO
Início da Iteração
Definição da Cálculo pelo Método “n”
quantidade de Barras Newton-Raphson
Resolução das
Definição do tipo das Definição do Erro %
derivadas parciais com
Barras Admitido
os valores adotados
Determinação das Criação da Matriz

grandezas elétricas Geração da Matriz Jacobiana a partir dos
das Barras Admitância valores obtidos acima
Fracionamento da Matriz Determinação do Δ entre

Definição da
Admitância em 2 Matrizes o valor adotado e o novo
Topologia de Rede
(Condutância e Susceptância) valor de incógnita
Determinação dos Criação das Equações Determinação dos

parâmetros das Diferenciais de Injeção Líquida novos valores das
linhas de transmissão de Potência para as Barras incógnitas
Definição das Criação das derivadas

2
Incógnitas parciais das funções
de Potência
Determinação dos Legenda

NÃO
Iniciar Cálculo? valores adotados para Ações do Usuário
início das iterações Ações do Algoritmo
SIM
Inícios
Resolução das equações de
Potência com os valores 2 Definições finais
obtidos das incógnitas
Os valores NÃO
Convergem?
SIM
Indica valor das

incógnitas na IHM
NÃO
Reiniciar Cálculos? Fechar Aplicativo
SIM
Figura 10 - Fluxograma detalhado do aplicativo

78
As etapas do fluxograma na cor verde representam o processo do algoritmo

apresentado anteriormente, onde o usuário não tem mais influência até que o
aplicativo retorne o resultado final das variáveis.
5.4 Desenvolvimento da Interface Homem Máquina

A IHM (Interface Homem Máquina) é parte primordial no desenvolvimento do
aplicativo, esta deve ser desenvolvida de forma a facilitar a interação e visualização
do sistema por parte do usuário. Pois todo o algoritmo tem seus inputs a partir dos
menus de seleção e inserção de dados do aplicativo, vale destacar que para este
projeto a interface foi desenvolvida de acordo com as etapas mostradas no fluxograma
da Figura 10 e por isso, a primeira interface desenvolvida foi da tela Inicial.
5.4.1 Desenvolvimento da Tela “Inicial”

A Figura 11 e o apêndice I mostram a programação em HTML da tela Inicial do
aplicativo. Na mesma é possível observar que a programação é composta
basicamente por duas partes o cabeçalho (head) e corpo do programa (body), cujos
conteúdos foram apresentados a seguir.
No head são declarados os links com outros elementos que compõe a

programação pelo comando “script”. Para a tela Inicial, os links são realizados com o
banco de dados e através da programação em Java Script. O comando “src” identifica
a origem do link. Por exemplo, o código da linha 20 significa que será feito um link
com um arquivo em Java Script, onde a origem situa-se em “js/jquery.js” e que nesse
caso, é o habilitador do banco de dados do aplicativo.
No body são programados os botões pelo comando “buton” e configurados para

executar diferentes funções através do comando “onclick”. Na linha 30, foi declarado
um botão e nomeado como “Continuar Simulação” através dos comandos “class” e
“id”. A nomeação tem a função de referenciar um elemento (no caso o botão) para as
outras linguagens de programação. O mesmo foi configurado para que com um clique,
direcione o aplicativo para a próxima página nomeada de “lista de componentes”. O
processo é semelhante para a linha 31, na qual foi declarado o botão “Nova
Simulação”. A diferença entre os dois está na configuração após o clique, que ao invés
79
de direcionar para a próxima página, é exibida uma mensagem de confirmação da

ação e efetuada a limpeza do banco de dados. Tais ações estão contidas na função
declarada na mesma linha. A finalidade de ter dois comandos o “class” e o “id” para
nomear um elemento é de ter configurações iguais e distintas para o mesmo. Pode-
se determinar por exemplo, que todos elementos nomeados pelo “class” sejam do
mesmo tamanho e que as cores sejam diferentes usando “id”. Ainda na tela Inicial, foi
programado um título para a página com o nome do projeto e uma imagem.
Figura 11 - Código fonte da tela Inicial
Com a programação em HTML sem a caracterização do CSS, a tela fica de

acordo com o que é mostrado na Figura 12, vale destacar que a programação em
CSS serve para customizar a página feita em HTML no aplicativo. Pode configurar
tipo, tamanho, cor e posição dos textos exibidos na tela, tamanho e cor dos botões e
também, mudar a aparência do plano de fundo.
80
Figura 12 - Tela Inicial do aplicativo sem a programação do CSS
5.4.2 Desenvolvimento da Tela “Lista de Componentes”

Depois da tela Inicial, a próxima página programada foi a lista de componentes.
As Figuras 13, 14 e o apêndice II mostram a programação em HTML da mesma, o
detalhamento da mesma foi apresentado a seguir.
O código começa pelo comando “div” para dividir a tela de acordo com os
elementos. Na linha 60, foi definido a parte superior da tela através dos comandos
“div” e “id”. O intuito de nomear uma divisão é para configura-la por meio do CSS, isto
pode ser percebido pela faixa vermelha na parte superior das telas do aplicativo.
Também foi definido para a mesma divisão, o título da página com o comando “h1” e
o botão com a forma de engrenagem que dá acesso ao menu de configuração dos
parâmetros matemáticos com os comandos “button” e “onclik”.
O programa segue com a divisão denominada “row” na linha 69. Este espaço
foi configurado em forma de tabela pelo comando “table” e é preenchido pelos
componentes adicionados.
E por último, foram declarados os botões da página que vão para as próximas
etapas nas linhas 97 a 101. O diferencial desta parte está nos botões com o símbolo
“+” e “x”, que ao invés de direcionar o usuário para outra tela, abre e fecha
respectivamente, um sub menu contendo os demais botões. Também, o botão
81
“APAGAR TUDO” não direciona para a próxima tela, mas sim, apaga os componentes
adicionados. Todos esses botões estão organizados no espaço definido pelo “div” e
nomeado como “menu”.
Figura 13 - Código fonte da tela Lista de Componentes
Figura 14 - Código fonte da tela Lista de Componentes
A Figura 15 mostra a página “Lista de Componentes” sem a programação do

CSS e com o sub menu aberto.
82
Figura 15 - Tela Lista de Componentes sem o CSS
5.4.3 Desenvolvimento da Tela “Add Componentes”

Seguindo para a próxima a etapa no fluxograma, tem-se a tela “Add
Componentes”, onde são inseridos os dados de entradas. Esta página funciona como
um formulário que coleta as informações dos elementos da rede e salva no banco de
dados. As Figuras 16, 17, 18, 19 e o apêndice III mostram a programação feita para a
mesma.
O código desta página conta com o comando “div” para dividi-la em: título, barra
de nome dos componentes, botão de seleção do tipo de componente e o botão
“INSERIR”. O botão do tipo de componente abre uma subdivisão de acordo com a
escolha do usuário onde fica as caixas de coleta de dados para o banco de dados.
Na linha 131 foi declarado o título da página “Entrada de dados” com o comando
“h1” na divisão feita na linha 130 e nomeada como “superior”.
Seguindo o código, na linha 133 foi utilizado o comando “p” para a inserção do
texto “Informe o Nome do Componente (Opcional)”. A diferença entre os comandos
“h1” e “p” é apenas a formatação padrão da fonte, mas a programação do CSS pode
83
altera-la e por isso os dois acabam tendo apenas a finalidade de escrever o texto que
aparece na tela.
Na linha 141, foi declarada uma caixa de texto para nomear os componentes
inseridos. Se caso não for preenchida, o programa cria um nome de acordo com a
posição no banco de dados. A mesma foi inserida com o comando “input” e
configurada para receber texto através do “type=’text’”. O tamanho da caixa foi
determinado pelo comando “style” para ocupar 8% da tela.
Após a inserção da caixa de texto, na divisão seguinte, foi colocado uma

imagem e mais um texto de advertência. Os comandos “td” e “width” determinam o
tamanho da imagem em porcentagem e o “src” a origem. Todas as figuras utilizadas
ficam salvas na pasta do próprio aplicativo para a compilação. O texto foi inserido com
o comando “span” que tem uma formatação padrão, mas também foi alterada pelo
CSS.
Na próxima divisão, foi declarado um texto e logo abaixo um botão de seleção

de componentes. Este elemento usa um comando diferente dos demais, pois habilita
os sub menu com as caixas de texto de dados de acordo com a escolha. Na linha 159
foi utilizado o comando “select” para declará-lo e através do “onchange” chama a
rotina em JavaScript para ativar os campos de configuração. Nas linhas 160 e 161
estão as opções que aparecem na tela.
Da linha 164 a 168 foi declarado a tela para os parâmetros de LT (linha de

transmissão) que é ativada pelo botão de seleção de componentes. O comando “label”
organiza o conteúdo na linha do código e funciona parecido com o “div”. A diferença
entre os dois é que o “label” divide a tela na vertical e o “div” na horizontal. A caixas
de texto foram inseridas pelo “input” e configuradas pelo “type” para que os caracteres
preenchidos sejam números, “style” para que o tamanho seja padrão, “pattern” que
limita os caracteres, “maxlength” que define o comprimento e “size” o tamanho. Ao
lado de cada caixa foi adicionado o nome do parâmetro.
Da linha 172 a 182 foi adicionado a tela para os parâmetros de barras também
ativada pelo botão de seleção de componentes. O comando “select” foi utilizado para
inserir o botão de seleção de tipos de barra. As caixas de texto de entradas de dados
seguem o mesmo padrão da tela de LT, muda apenas nos nomes dos parâmetros e
84
a quantidade de 4 para 2. Outra característica importante é o preenchimento

automático para o caso da barra de referência.
Por último foi o botão “INSERIR” que utiliza o comando “input” configurado com
o “type=button” e com o “onclick” que direciona o usuário para a página “lista de
componentes” onde os elementos adicionados são organizados em forma de tabela.
Figura 16 - Código fonte tela Add Componentes

85
As Figuras 20 e 21 mostram as telas Add Componentes sem a caracterização

feita no CSS para cada tipo de elemento (barra ou linha).
Figura 20 - Tela Add Componentes para barra Figura 21 - Tela Add Componentes para LT
5.4.4 Desenvolvimento Da Tela “Configurações”

A tela de Configurações pode ser acessada pelo botão em forma de
engrenagem no canto superior da página Lista de Componentes. As Figuras 22, 23 e
o apendice IV mostram o código fonte da mesma.
86
Na linha 33 foi adicionado o título com o comando “h1” na parte superior da tela
e logo abaixo a mesma imagem e texto de advertência presentes na página Add
Componentes.
Nas linhas 51, 54 e 57 foram inseridos os textos “Erro Máx:”, “Número Máximo
de Iterações” e “Sbase(MVA)” respectivamente através do comando “p” e nas linhas
52, 55 e 58 as caixas de texto com o mesmo padrão presente no menu ativado para
LT. Por último foi o botão “CONFIRMAR” feito através do comando “input” e
configurado para direcionar o usuário de volta a tela Lista de Componentes com o
“onclick”.
Figura 22 - Código fonte da tela Configurações
Figura 23 - Código fonte da tela Configurações

87
A Figura 24 mostra a página Configurações.
Figura 24 - Tela Configurações
5.4.5 Desenvolvimento da Tela “Resultados”

A tela Resuldados mostra os valores obtidos pelo aplicativo das incognitas
declaradas pelo usuário. A mesma foi desenvolvida com dois botões que ativam as
tabelas com os resultados. Vale ressaltar que só aparece conteudo na página quando
são gerados os calculos com os resultados. A Figura 25 e o apêndice V mostram a
programação da página Resultados.
Na linha 18 foi declarado o título com o comando “h1” na divisão denominada

“superior” feita atraves do “div” e “id”, ou seja, no canto superior da tela aparecerá a
mensagem “Fluxos Calculados”.
Nas linhas 24 e 25 foram declarados os botões configurados para exibir os

resultados. Os comandos utilizados foram: “button” para programar o botão; o ”class”
para definir o elemento do tipo tabela e o “onclick” para ativar o resultado oculto após
o clique. É importante lembrar que após o aplicativo processar o cálculo e chegar ao
resultado final, os fluxos e as perdas serão exibidos primeiro.
88
Figura 25 - Código fonte tela Resultados
5.5 Versões Finais das Telas

Com a programação do CSS, as páginas exibidas no aplicativo ficam de acordo
com as apresentadas nos itens a seguir.
5.5.1 Versão Final da Tela “Inicial”

Inicialmente apresenta-se ao usuário uma página com um diagrama simulando
uma rede, onde sobre este estão dois botões que dão início a um novo cálculo ou
permitem o usuário fazer alterações nos parâmetros de rede do cálculo anterior e
assim efetuar novo cálculo, a mesma é ilustrada na Figura 26.
Figura 26 - Tela Inicial do aplicativo com CSS

89
5.5.2 Versão Final da Tela “Lista de Componentes”

Uma vez que o usuário decide iniciar uma nova simulação, exibe-se uma
página na qual possui um botão com um sinal de “+”, onde este permite a ativação do
sub menu com os botões de inserção de componentes da rede (linhas e barras),
“APAGAR TUDO” e também “CALCULAR FLUXO”. O botão de apagar tudo zera o
banco de dados onde estão salvos os componentes adicionados. E o de calcular fluxo
será abordado depois. Nas Figuras 27 e 28, é possível visualizar a interface de adição
de componentes da rede, calcular fluxo ou apagar tudo.
Figura 27 - Tela Lista de Componentes com Figura 28 - Tela Lista de Componentes com
CSS CSS e sub menu
5.5.3 Versão Final da Tela “Add Componentes”

Após escolher a opção “ADD COMPONENTE”, mostra-se a tela de seleção de
componentes, podendo ser barra ou linha de transmissão. Nessa etapa, define-se o
número barras adicionando de acordo com a rede que deseja simular e conforme seja
o tipo de componente escolhido, exibe-se uma tela diferente de configuração, na
Figura 29 mostra a tela de seleção do tipo de componentes.
90
Figura 29 - Tela Add Componentes com CSS e menu flutuante
Tendo selecionado um componente, disponibiliza-se os campos para inserir os

parâmetros da barra (tipo e grandezas respectivas) ou da linha (reatância, resistência
e susceptância shunt). Para que o algoritmo funcione corretamente, precisa-se ter
uma referência por meio de uma barra. Então, faz-se necessário que na configuração
dos componentes, umas das barras adicionadas seja do tipo Vθ. E também, nesta
mesma etapa, definir a origem e destino das linhas de transmissão, tal processo é
responsável pela definição da topologia da rede, nas Figuras 30 a 33 exibem a tela de
configuração dos componentes de acordo com o que foi escolhido.
91
Figura 31 – Tela Add Componentes Figura 30 – Tela Add Componentes

com CSS para barra PV com CSS para barra Vθ
Figura 32 – Tela Add Componentes Figura 33 – Tela Add Componentes

com CSS para barra PQ com CSS para LT
92
5.5.4 Versão Final da Tela “Configurações”

Com os componentes inseridos e configurados, precisa-se definir os limites do
cálculo que são: o número máximo de iterações, o erro admissível e a potência de
base. O menu de seleção pode ser acessado pelo botão em formato de engrenagem
localizado no canto superior direito do aplicativo, a Figura 34 mostra a tela de
configuração dos limites matemáticos.
Figura 34 – Tela Configurações com CSS
5.5.5 Versão Final da Tela “Resultados”

Após a definição dos componentes de rede e dos limites matemáticos para o
aplicativo, pode-se iniciar o cálculo através de uma das opções disponíveis no menu
da tela principal, utilizando o botão “Iniciar Cálculo” o aplicativo determinará as
variáveis e fluxos da rede em questão, com a finalização do cálculo por parte do
algoritmo, o aplicativo exibe duas tabelas sendo uma com o valor do fluxo de potência
entre as barras da rede em análise e a outra aba contendo os valores de tensão e
ângulo de fase em cada barra.
As Figuras 35 e 36 contém a ilustração das duas abas onde o aplicativo

apresenta um exemplo de resultados finais.
93
Figura 35 - Tela Resultados com Figura 36 – Tela Resultados com

CSS e aba de fluxos CSS e aba de tensões
Posteriormente a apresentação do resultado pode-se retornar para o menu

inicial e então optar por realizar um novo cálculo referente a uma nova rede, ou mudar
os parâmetros da rede em questão e calcular novamente os fluxos e os parâmetros
das barras.
5.6 Testes Finais do Aplicativo

Os testes apresentados a seguir foram realizados em acordo com o capítulo 4
deste documento e também pelo usuário afim de receber o feedback da IHM.
5.6.1 Teste de Performance do Aplicativo

O teste do sistema integrado foi realizado com diversas marcas e modelos de
smartphones. Foi simulado os casos de 3 barras (mais usual durante uma aula) e 14
barras (pior caso previsto) do IEEE e os resultados podem ser vistos na tabela 21.
94
Tabela 21 - Teste de performance
3 BARRAS 14 BARRAS
MARCA MODELO PROCESSADOR
ERRO TEMPO ERRO TEMPO
Motorola G5 Plus Octa-core 2GHz 0% 4.59s 0% 4min19s
Samsung Galaxy S7 Octa-core 2,3GHz 0% 3.15s 0% 2min27s
Motorola G7 Play Octa-core 1,8GHz 0% 3.22s 0% 10min36s
Xiaomi MI A1 Octa-core 2GHz 0% 3.96s 0% 4min6s
Como pode ser observado na tabela 21, o tempo de resposta depende da

marca, modelo e velocidade do processador, porém a precisão é a mesma para todos.
Isso deve-se ao fato de que o resultado não depende de uma característica própria
do smartphone usado, e sim do algoritmo implementado no aplicativo. Já o tempo de
resposta depende principalmente da velocidade de processamento. Mesmo passando
por vários processos de otimização desde os primeiros códigos até o final
apresentado, o aplicativo necessita ainda de recursos otimizadores para melhorar o
tempo de processamento.
5.6.2 Teste de Performance da IHM

De acordo com o Prof. Dr. Alexandre Rocco que ministra as aulas de Sistemas
de Potência II da Universidade Santa Cecília e o principal cliente, a interface
apresentada no aplicativo atendeu a expectativas sendo amigável e intuitiva podendo
ser compreendida em poucos minutos. E ainda destaca: “A ideia de se desenvolver o
aplicativo foi bastante interessante para os alunos poderem compreender melhor os
algoritmos que estão inseridos no desenvolvimento, que tenha realmente um
endereçamento de utilização que possa ser expandido para utilização de várias áreas
da elétrica. E também, mostrar que hoje estamos em um outro ponto de aplicação,
que consegue colocar softwares que seriam uns anos atrás de utilização massiva de
sistemas de informática com grande tempo de processamento e sistemas mal feitos.
E que consegue reduzir essas aplicações de utilização em celulares com boa
razoabilidade de resultados, com as aproximações bem interessantes e a modelagem
da rede também com bastante flexibilidade. Então, o grupo atingiu os objetivos do
TCC e também desenvolveu uma aplicação de bastante interesse da comunidade e
que gera outros trabalhos relacionados.” (Rocco, Alexandre, 2019).
95
5.7 Conclusões Parciais

As principais conclusões obtidas neste capítulo foram apresentadas nos itens
descritos a seguir:
• Com a integração dos sistemas de cálculo e interface, o aplicativo manteve-se

sem muitas alterações quanto ao seu desempenho;
• Em relação ao teste para aferição da precisão dos resultados, estes foram
satisfatórios, mantendo a alta precisão de quando o sistema ainda apresentava
uma interface simples;
• Ainda em relação a precisão dos resultados, verificou-se que houve pequenos
desvios em redes com um número elevado de elementos, porém, para
aplicações didáticas, que geralmente envolve um número menor de elementos,
os resultados foram bastantes precisos e por isso de forma geral foram
satisfatórios;
• Também foi verificado que o tempo de resposta do cálculo depende da
velocidade do processador do smartphone usado e do tamanho da rede
simulada;
• A IHM ficou de acordo com o que foi proposto e atendendo as necessidades.
A mesma foi construída de forma que seja intuitiva para que o usuário aprenda
e explore naturalmente e faça os cálculos de forma rápida e objetiva. A
integração das três linguagens utilizadas foi o fator determinante para o alcance
de tais resultados. Nesse ponto, destaca-se o dinamismo que o JavaScript
oferece para o HTML fazendo com que seja otimizado as linhas de códigos e
tornando as telas mais simples e organizadas;
• Em vista do que foi exposto no presente capítulo, os resultados alcançados
foram satisfatórios para o grupo e para o cliente, atendendo a necessidades
impostas para o uso em aula.
96
CAPÍTULO 6 – CONCLUSÕES
Neste último capítulo são apresentadas as considerações finais em relação ao
objetivo do programa desenvolvido.
6.1 Conclusões Finais

O desenvolvimento do Power Flow foi bastante satisfatório, atendendo à
solicitação do Prof. Dr. Alexandre Rocco de elaborar uma plataforma para cálculo de
fluxo de potência que permitisse analisar as relações e topologia de rede, visto que,
até o momento não havia um software mobile de porte acadêmico para auxiliar a
ministrar as aulas de Sistemas de Potências. Além disto, agrega em caráter de
informatização e tecnologia para a sala de aula. As principais conclusões observadas
neste trabalho foram citadas a seguir:
a) Apesar de ter apresentado pequenos erros percentuais, o aplicativo

demonstrou bastante assertividade nos cálculos, visto que foi realizado um
estudo comparativo tendo como referência o programa ANAREDE e utilizando
sistemas elétricos padronizados pelo IEEE e os resultados do aplicativo
desenvolvido foram eficazes.
b) O algoritmo desenvolvido demonstrou ser efetivo para sua finalidade de auxiliar
no cálculo dos fluxos para sistemas de até 3 barras, demonstrando as relações
e a topologia de rede, pois possibilita visualizar o resultado em menor tempo
do que os cálculos manuais, otimizando o tempo gasto com isto em sala de
aula. Portanto, o presente trabalho satisfez o objetivo definido inicialmente.
c) Quanto ao tempo de processamento, como a maioria dos cálculos realizados
em sala de aula não ultrapassam 3 barras o tempo para a realização do cálculo
será em alguns segundos. E, apesar de demorar alguns minutos, também
possibilita acrescentar análises com mais barras em tempo muito menor que
calcular manualmente.
d) O aplicativo desenvolvido apresentou uma interface bem amigável, intuitiva e
de fácil compreensão, agradando aos alunos e ao professor, que são os
usuários finais;
e) Por fim, pode-se dizer que o aplicativo superou as expectativas, pois o primeiro
projeto trabalhava com sistemas elétricos de no máximo 3 barras, porém, com
97
o amadurecimento do algoritmo foi possível que o programa calculasse os

fluxos e perdas com um número “n” de barras, sendo “n” definido pelo usuário.
Além do amadurecimento do algoritmo, a interface gráfica também possibilitou
a visualização dos resultados de forma bastante amigável e com fácil
interpretação.
6.2 Propostas para Trabalhos Futuros

O presente trabalho foi uma iniciativa de trazer funções de níveis industriais
para fins didáticos, sendo tangíveis aos alunos. Porém, algumas alterações podem
ser feitas para melhor interação com os estudantes, ou, até mesmo, adaptações para
fins comerciais, como:
a) Avaliando as funções do ANAREDE com o Power Flow, a principal função não

realizada pelo último é a demonstração gráfica do sistema elétrico, além dos
resultados numéricos. Portanto, uma das melhorias sugeridas é o
desenvolvimento de uma representação gráfica e, possivelmente, iterativa dos
sistemas elétricos. Assim, a interface tornar-se-ia mais amigável e de fácil
visualização dos sentidos de fluxos;
b) Além disso, para tornar o sistema de inserção de dados mais fácil e rápido,
também é sugerido uma adaptação para armazenamento de dados
provenientes de planilhas, ou seja, inserir uma tabela do Excel, por exemplo,
com todos os dados já definidos. Isso traria mais agilidade, visto que os dados
seriam inseridos de uma só vez. Porém, seria necessário alterar a plataforma
de desenvolvimento, visto que o banco de dados compatível com o Phonegap
possui recursos limitados. Com esta metodologia de inserção de dados através
de tabelas, o aplicativo poderia ser utilizado até mesmo para fins comerciais,
visto que o mesmo possui uma interface gráfica mais amigável que o
ANAREDE e pode ser utilizado em qualquer lugar através de smartphones;
c) Para tornar o aplicativo mais didático, também é sugerido uma adaptação para
demonstração do passo a passo do cálculo para que o usuário consiga avaliar
cada detalhe das iterações, como matrizes e equações formadas durante o
desenvolvimento do mesmo.
98
REFERÊNCIAS
A seguir, as referências dos materiais consultados para base do desenvolvimento e estudo
do conteúdo teórico.
ANTUNES, Vinícius José Lindolpho, Desenvolvimento de um software didático para

análise do cálculo do fluxo de potência – PF Analyst. Trabalho de Conclusão de Curso
de Engenharia Elétrica apresentado na Universidade Federal do Paraná, Curitiba-PR,
2007. <Disponível em: http://www.eletrica.ufpr.br/ufpr2/tccs/21.pdf>. Acessado em
14/03/2019, 21h:28min.
CANOSSA, Jâine Henrique. Um programa interativo para estudos de fluxo de

potência. Dissertação de Mestrado apresentada na Universidade Estadual Paulista –
Campus de Ilha Solteira, Ilha Solteira-SP, 2007. <Disponível em:
https://repositorio.unesp.br/handle/11449/87243>. Acessado em 14/03/2019, 21h:
25min.
CHAVES, Simone Bezerra. Análise estática e dinâmica de sistemas de potência via

aplicativo computacional integrado: ORGANON. Dissertação de Mestrado
apresentada na Universidade Federal de Fluminense, Niterói-RJ, 2008. <Disponível
em:
https://www.researchgate.net/publication/324706616_ANALISE_ESTATICA_E_DINA
MICA_DE_SISTEMAS_DE_POTENCIA_VIA_APLICATIVO_COMPUTACIONAL_INT
EGRADO_ORGANON>. Acessado em 28/02/2019, 21h:45min.
GOMES, Daniel Armando Arias. Identificação das barras críticas do ponto de vista de
estabilidade de tensão. Dissertação de Mestrado apresentada na Pontifícia
Universidade Católica do Rio de Janeiro, Rio de Janeiro, 2015, cap. 3. <Disponível
em: https://www.maxwell.vrac.puc-
rio.br/colecao.php?strSecao=resultado&nrSeq=26243@1>. Acessado em
16/05/2019, 21h:15min.
99
KNITTEL, Tânia Filomena. A utilização de dispositivos móveis como ferramenta de

ensino-aprendizagem em sala de aula. Dissertação de Mestrado em Mídias Digitais.
Pontifícia Universidade Católica de São Paulo, São Paulo, 2014, p. 9. < Disponível
em: https://tede2.pucsp.br/handle/handle/18164 >. Acesso em 10/03/2019, 19:50min.
MONTICELLI, Alcir; GARCIA, Ariovaldo. Introdução a sistemas de energia elétrica.

Campinas-SP: Editora: Unicamp, 2003.
Phonegap. Crie seu app com Phonegap. 2016. <Disponível em:

https://phonegap.com/>. Acessado em 22/10/2019, 22h50min.)
SOAD, Gustavo Willians. Avaliação de qualidade em aplicativos educacionais móveis.

Dissertação de Mestrado do Programa de Pós-Graduação em Ciências de
Computação e Matemática Computacional (PPG-CCMC). Universidade de São Paulo,
São Carlos, 2017, p. 21 e 25. <Disponível em:
http://www.teses.usp.br/teses/disponiveis/55/55134/tde-27092017-173643/pt-
br.php>. Acesso em 10/03/2019, 19:30min.
100
APÊNDICE I – CÓDIGO FONTE DA TELA “INICIAL”
<!DOCTYPE html>
<html lang="pt-br">
<head>
<meta charset="utf-8" />
<meta name="format-detection" content="telephone=no" />
<meta name="msapplication-tap-highlight" content="no" />
<meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-
scale=1, minimum-scale=1, width=device-width" />
<meta http-equiv="Content-Security-Policy" content="default-src * 'unsafe-inline';
style-src 'self' 'unsafe-inline'; media-src *" />
<link rel="stylesheet" type="text/css" href="css/index.css" />
<div id="superior">
<h1>Power Flow</h1>
</div>
</head>
<script type="text/javascript" src="cordova.js"></script>
<script type="text/javascript" src="js/jquery.js"></script>

<script type="text/javascript" src="js/index.js"></script>
<script type="text/javascript">
</script>
<body>
<p align="center" class="tela_inicial_title"> Tela Inicial </p>

<div id="index_buttons">
<button class="button_index" id="continuar_simulação" onclick="window.location =
'lista de componentes.html'" >CONTINUAR<br/>SIMULAÇÃO</button>
101
<button class="button_index" id="nova_imulação"onclick="nova_simulação()"

>NOVA<br/>SIMULAÇÃO</button></br></br>
</div>
<img src="img/imagemdatela.png" class="Image_screen"/></br></br> //IMAGEM
<p align=center class="Power_Flow_title"> Power Flow</p>
</body>
</html>
102
APÊNDICE II – CÓDIGO FONTE DA TELA “LISTA DE

COMPONENTES”
<!DOCTYPE html>
<html lang="pt-br">
<head>

<title> LISTA DE COMPONENTES </title>
</head>

function onLoad() {
document.addEventListener("deviceready", onDeviceReady, false);
}
function onDeviceReady() {
document.addEventListener("backbutton", onBackKeyDown, false);
}
function onBackKeyDown() {
window.location='index.html';
}
103
function SUBMENU_VISÍVEL() {
document.getElementById("addcompo").hidden = false;
document.getElementById("calcflux").hidden = false;;
document.getElementById("X").hidden = false;;
document.getElementById("apagtudo").hidden = false;;
}
function SUBMENU_INVISÍVEL() {
document.getElementById("addcompo").hidden = true;
document.getElementById("calcflux").hidden = true;
document.getElementById("X").hidden = true;
document.getElementById("apagtudo").hidden = true;
onLoad();
}
</script>
<div id="superior">
<h1>Lista de Componentes</h1>
<div id="alinhamento_config">
<input type='button' class='button_config'
onclick="window.location='configuracoes.html'">
</div>
</div>
<input type="hidden" id="barras_id_delete">
<input type="hidden" id="linhas_id_delete">
<div class="row">
<div class="col-md-12">
<table class="table">
<thead>
<tr>
</tr>
104
</thead>
<tbody id ="barras_listagem">
</tbody>
</table>
</div>
</div>
<div class="row">
<thead>
<tr>
</tr>
</thead>
<tbody id ="linhas_listagem">
</tbody>
</table>
</div>
</div>
<body onload="SUBMENU_INVISÍVEL()">
<div id="menu">
<button class="button_close" id="X" onclick="SUBMENU_INVISÍVEL()"
hidden>x</button></br></br>
<button class="button_option" id="addcompo" onclick="window.location =
'addcomponente.html'"hidden>ADD COMPONENTE</button></br></br>
<button class="button_option" id="calcflux"onclick="window.location =
'calcularfluxo.html'" hidden>CALCULAR FLUXO</button></br></br>
<button class="button_option" id="apagtudo"onclick="nova_simulação()"
hidden>APAGAR TUDO</button></br></br>
<button class="button_open" onclick="SUBMENU_VISÍVEL()">+</button></br></br>
</div>
105
<script>
barras_view();
linhas_view();
</script>
</body>
</html>
106
APÊNDICE III – CÓDIGO FONTE DA TELA “ADD COMPONENTES”
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-
awesome.min.css" rel="stylesheet" integrity="sha384-
wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVn
N" crossorigin="anonymous">
<title>Entrada de Dados</title>
</head>
<body style="margin-left:5%;margin-top:15%;">
function ativacampos(){
selecionado = document.getElementById("tipocomp").value;
if(selecionado=="Barra"){
document.getElementById("opcoes_barra").style.display = "inline";
document.getElementById("opcoes_linha").style.display = "none";
document.getElementById("rs").value = "";
107
document.getElementById("xs").value = "";
document.getElementById("bsh").value = "";
document.getElementById("linhaorig").value = "";
document.getElementById("linhadest").value = "";
}
else{
document.getElementById("opcoes_barra").style.display = "none";
document.getElementById("opcoes_linha").style.display = "inline";
}
}
function ativadados(){
escolhido = document.getElementById("tipobar").value;
if(escolhido=="V0"){
document.getElementById("indicadorV").style.display = "inline";
document.getElementById("V").style.display = "inline";
document.getElementById("V").value = "1";
document.getElementById("V").disabled = true;
document.getElementById("indicadortheta").style.display = "inline";
document.getElementById("theta").style.display = "inline";
document.getElementById("theta").value = "0";
document.getElementById("theta").disabled = true;
document.getElementById("indicadorP").style.display = "none";
document.getElementById("P").style.display = "none";
document.getElementById("P").value = "";
document.getElementById("P").disabled = true;// add agr
document.getElementById("indicadorQ").style.display = "none";
document.getElementById("Q").style.display = "none";
document.getElementById("Q").value = "";
document.getElementById("Q").disabled = true;// add agr
108
else if(escolhido=="PV"){
document.getElementById("V").value = "";
document.getElementById("V").disabled = false;
document.getElementById("indicadortheta").style.display = "none";
document.getElementById("theta").style.display = "none";
document.getElementById("theta").value = "";
document.getElementById("theta").disabled = true;// original era disabled
document.getElementById("indicadorP").style.display = "inline";
document.getElementById("P").style.display = "inline";
document.getElementById("P").disabled = false;
document.getElementById("Q").disabled = true; // add agr
}
else{
document.getElementById("indicadorV").style.display = "none";
document.getElementById("V").style.display = "none";
109
document.getElementById("P").disabled = false;// add agr
document.getElementById("indicadorQ").style.display = "inline";
document.getElementById("Q").style.display = "inline";
document.getElementById("Q").disabled = false;// add agr
}
}
function EnterTab(InputId,InputId1,InputId2,Evento){
selecionado = document.getElementById("tipocomp").value;
if(Evento.keyCode == 13){
document.getElementById(InputId).focus();
document.getElementById(InputId1).focus();
if(escolhido=="V0"&& selecionado=="Barra"){
}
}
}
</script>
<div id="superior">
<h1>Entrada de dados</h1>
</div>
<p class="fonte">Informe o Nome do Componente(Opcional):</p>

<div class="container">
110
<div class="row">
<input type="text" class="form-control" id="box" style="margin-bottom:8%;"
onkeydown="javascript:EnterTab('P','rs','inserir',event)"/>
<br>
<div class="apparent-message warning-message">

<div class="message-container">
<div class="apparent-message-icon fa fa-fw fa-2x fa-exclamation-triangle">
<td width='100'><img src='img/aviso.png' class="imagem-aviso"></td>
</div>
<div class="content-container">
<div class="message-header">
<span>Aviso</span>
</div>
<div class="message-body">Utilize ponto para indicar números decimais.</div>
</div>
</div>
</div>
<br>
<p class="fonte">Selecione o Tipo de Componente:</p>
<select id="tipocomp" name="selectcomp" onchange="ativacampos()"
class="select">
<option value="Barra" selected>Barra </option>

<option value="Linha">Linha</option>
</select></br></br>
<div id="opcoes_linha" style="display:none;">
<label id=indicadorrs><p class="fonte" style="display:inline-
block;">Rs</p>:</label><input type="tel" pattern="(?:\.[0-9])" maxlength="8" size="4"
name="rs" id="rs" class="dados" onkeydown="javascript:EnterTab('xs',0,0,event)"/>
<label id=indicadorxs><p class="fonte" style="display:inline-
block;">Xs:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="xs" id="xs"
111
class="dados"onkeydown="javascript:EnterTab('bsh',0,0,event)"/></br></br>
<label id=indicadorjb><p class="fonte" style="display:inline-

block;">B<sup>sh</sup>:</p></label><input type="tel" pattern="[0-9]{8}"
maxlength="8" size="4" name="bsh" id="bsh"
class="dados"onkeydown="javascript:EnterTab('linhaorig',0,0,event)"/></br></br>
<label id=indicadororig><p class="fonte" style="display:inline-block;">Entre
Barras:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="3" size="3"
name="origem" id="linhaorig"
class="dados"onkeydown="javascript:EnterTab('linhadest',0,0,event)"/>
<label id=indicadordest><p class="fonte" style="display:inline-
block;">e</p></label><input type="tel" pattern="[0-9]{8}" maxlength="3" size="3"
name="destino" id="linhadest"
class="dados"onkeydown="javascript:EnterTab('inserir',0,0,event)"/></br></br>
</div>
<div id="opcoes_barra">
<label id=indicadortipobar><p class="fonte" style="display:inline-block;">Tipo de
Barra:</p></label><select id="tipobar" name="selectbar" onchange="ativadados()"
class="select">
<option value="V0" selected>Vθ</option>
<option value="PV">PV</option>
</select></br></br>
<label id=indicadorP style="display:none;"><p class="fonte" style="display:inline-

block;">P:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="P" id="P" style="display:none;" class="dados"
onkeydown="javascript:EnterTab('Q','V',0,event)"/>
<label id=indicadorQ style="display:none;"><p class="fonte" style="display:inline-
block;">Q:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="Q" id="Q" style="display:none;" class="dados"
onkeydown="javascript:EnterTab('inserir',0,0,event)"/>
<label id=indicadorV><p class="fonte" style="display:inline-
block;">V:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="V" id="V" disabled="true" value="1" class="dados"
<label id=indicadortheta><p class="fonte" style="display:inline-

block;">θ:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8"
size="4" name="Theta" id="theta" disabled="true" value="0"
class="dados"/></br></br>
</div>
112
<br>
<br>
<input type="button" class="button_insert" value="INSERIR" onclick="barras_insert()"
id="inserir">
<br>
<br>
</div>
</div>
<div class="row">
<thead>
<tr>
</tr>
</thead>
</tbody>
</table>
</div>
</div>
<div class="row">
<thead>
<tr>
</tr>
</thead>
</tbody>
</table>
113
</div>
</div>
</div>
</body>
</html>
114
APÊNDICE IV – CÓDIGO FONTE DA TELA “CONFIGURAÇÕES”
<!DOCTYPE html>
<html>
<head>
<title>Configurações</title>
</head>
<body style="margin-left:5%;margin-top:15%;" onload="Carrega_config()">

function EnterTab(InputId,Evento){
}
}
</script>
<div id="superior">
<h1>Configurações</h1>
</div>
115
</div>
<span>Aviso</span>
</div>
</div>
</div>
</div>
<br>
<p class="fonte">Erro Máx:</p>

<input type="tel" pattern="[0-9]{8}" maxlength="8" size="4" name="rs" id="Erro_max"
class="dados" onkeydown="javascript:EnterTab('Num_iterações',event)"/>
<br><br>
<p class="fonte">Número Máximo de Iterações:</p>

<input type="tel" pattern="[0-9]{8}" maxlength="8" size="4" name="rs"
id="Num_iterações"
class="dados"onkeydown="javascript:EnterTab('S_base',event)"/>
<br><br>
<p class="fonte">S<sub>base</sub> (MVA):</p>
<input type="tel" pattern="[0-9]{8}" maxlength="8" size="4" name="rs" id="S_base"
class="dados" onkeydown="javascript:EnterTab('confirmar',event)"/>
<br><br>
<input type="button" class="button_insert" value="CONFIRMAR"
onclick="confirmar_configurações()" id="confirmar">
</body>
</html>
116
APÊNDICE V – CÓDIGO FONTE DA TELA “RESULTADOS”
<!DOCTYPE html>
<html lang="pt-br">
<head>
<link rel="stylesheet" href="css/carregamento-de-pagina.css"/>

<title> Fluxos Calculados </title>
</head>
<div id="superior">
<h1>Fluxos Calculados</h1>
</div>
<body onload="calcular_fluxo()">
<div class="tab" align="center" id="fluxos_linhas" style="display:none;">

<button class="tablinks" onclick="openCity(event, 'resultados')"
id="defaultOpen">FLUXOS</button>
<button class="tablinks" onclick="openCity(event,
'resultados2')">TENSÕES</button>
</div>
<div id="status_message" align="center">
</div>
117
<div id="resultados" align="center" class="tabcontent">
</div>
<div id="resultados2" align="center" class="tabcontent">
</div>
</body>

<script type="text/javascript" src="js/math.min.js"></script>
<script type="text/javascript" src="js/pace.js"></script>
<script>
document.getElementById("defaultOpen").click();
function openCity(evt, cityName) {
var i, tabcontent, tablinks;

tabcontent = document.getElementsByClassName("tabcontent");
for (i = 0; i < tabcontent.length; i++) {
tabcontent[i].style.display = "none";
}
tablinks = document.getElementsByClassName("tablinks");
for (i = 0; i < tablinks.length; i++) {

tablinks[i].className = tablinks[i].className.replace(" active", "");
}
document.getElementById(cityName).style.display = "block";
evt.currentTarget.className += " active";
}
</script>
118
APÊNDICE VI – CÓDIGO FONTE DA TELA “EDITAR

COMPONENTES”
<!DOCTYPE html>
<html>
<head>

<title>Entrada de Dados</title>
</head>
<body onload="what()" style="margin-left:5%;margin-top:15%;">

<script type="text/javascript" src="js/editarcompo.js"></script>
function ativadados(){
if(escolhido=="V0")
{
document.getElementById("V").value = "1";
document.getElementById("indicadortheta").style.display = "inline";
119
document.getElementById("theta").style.display = "inline";
document.getElementById("theta").value = "0";
document.getElementById("indicadorP").style.display = "none";
document.getElementById("P").style.display = "none";
document.getElementById("P").disabled = true;// add agr
document.getElementById("Q").disabled = true;// add agr
}
else if(escolhido=="PV")//caso PV{
document.getElementById("V").disabled = false;
document.getElementById("theta").disabled = true;// original era disabled

document.getElementById("P").disabled = false;
document.getElementById("Q").disabled = true; // add agr
120
else //caso PQ{

document.getElementById("indicadorV").style.display = "none";
document.getElementById("V").style.display = "none";
document.getElementById("P").disabled = false;// add agr
document.getElementById("indicadorQ").style.display = "inline";
document.getElementById("Q").style.display = "inline";
document.getElementById("Q").disabled = false;// add agr
}
}
function EnterTab(InputId,InputId1,InputId2,Evento){
if(escolhido=="V0"&& tipo_elemento=="barra"){
}
}
121
</script>
<div id="superior">
<h1>Editar Componente</h1>
</div>

<div class="container">
<div class="row">
<p class="fonte"style="margin-top:8%;">Informe o Nome do
Componente(Opcional):</p>
<input type="text" class="form-control" id="box"
onkeydown="javascript:EnterTab('P','rs','inserir',event)">
</br>
<div id="tipo_de_compo" style="display:none;">

<p id="selecione_text">Selecione o Tipo de Componente:</p>
<select id="tipocomp" name="selectcomp" onchange="linhas_altera()"
class="select">
<option value="Barra" selected>Barra </option>

<option value="Linha">Linha</option>
</select></br></br>
</div>
<br>
</div>
122
<span>Aviso</span>
</div>
</div>
</div>
</div>
<br>
<div id="opcoes_linha" style="display:none;">
<label id=indicadorrs><p class="fonte" style="display:inline-
block;">Rs</p>:</label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="rs" id="rs" class="dados" onkeydown="javascript:EnterTab('xs',0,0,event)"/>
<label id=indicadorxs><p class="fonte" style="display:inline-
block;">Xs:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="xs" id="xs" class="dados"
onkeydown="javascript:EnterTab('bsh',0,0,event)"/></br></br>
<label id=indicadorjb><p class="fonte" style="display:inline-

block;">B<sup>sh</sup>:</p></label><input type="tel" pattern="[0-9]{8}"
maxlength="8" size="4" name="bsh" id="bsh" class="dados"
onkeydown="javascript:EnterTab('linhaorig',0,0,event)"/></br></br>
<label id=indicadororig><p class="fonte" style="display:inline-block;">Entre
Barras:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="3" size="3"
name="origem" id="linhaorig" class="dados"
onkeydown="javascript:EnterTab('linhadest',0,0,event)"/>
<label id=indicadordest><p class="fonte" style="display:inline-
block;">e</p></label><input type="tel" pattern="[0-9]{8}" maxlength="3" size="3"
name="destino" id="linhadest" class="dados"
onkeydown="javascript:EnterTab('inserir',0,0,event)"/></br></br>
</div>
<div id="opcoes_barra">
<label id=indicadortipobar><p class="fonte" style="display:inline-block;">Tipo de
Barra:</p></label><select id="tipobar" name="selectbar" onchange="ativadados()"
class="select">
<option value="V0">Vθ</option>
<option value="PV">PV</option>
123
</select></br></br>
<label id=indicadorP style="display:none;"><p class="fonte" style="display:inline-

block;">P:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="P" id="P" style="display:none;" class="dados"
onkeydown="javascript:EnterTab('Q','V',0,event)"/>
<label id=indicadorQ style="display:none;"><p class="fonte" style="display:inline-
block;">Q:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="Q" id="Q" style="display:none;" class="dados"
<label id=indicadorV><p class="fonte" style="display:inline-
block;">V:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8" size="4"
name="V" id="V" disabled="true" value="1" class="dados"
<label id=indicadortheta><p class="fonte" style="display:inline-
block;">θ:</p></label><input type="tel" pattern="[0-9]{8}" maxlength="8"
size="4" name="Theta" id="theta" disabled="true" value="0"
class="dados"/></br></br>
</div>
<br>
<br>
<input type="button" class="button_insert" value="ALTERAR"

onclick="alterar_componente()" id="inserir">
<br>
<br>
</div>
</div>
<div class="row">
<thead>
<tr>
</tr>
</thead>
</tbody>
124
</table>
</div>
</div>
<div class="row">
<thead>
<tr>
</tr>
</thead>
</tbody>
</table>
</div>
</div>
</div>
</body>
</html>

Monografia-2019 VFINAL

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Monografia-2019 VFINAL

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE SANTA CECÍLIA

CURSO DE ENGENHARIA ELÉTRICA

DOUGLAS SILVA CRUZ

FELIPE PEREIRA MUNIZ SILVA

INGRID ARRUDA RAMIL DOS SANTOS

MATHEUS RICHARDSON DOS SANTOS ANTUNES

PEDRO HENRIQUE ALMEIDA MERLIN

APLICATIVO MOBILE PARA CÁLCULO DE

UNIVERSIDADE SANTA CECÍLIA

CURSO DE ENGENHARIA ELÉTRICA

DOUGLAS SILVA CRUZ

FELIPE PEREIRA MUNIZ SILVA

INGRID ARRUDA RAMIL DOS SANTOS

MATHEUS RICHARDSON DOS SANTOS ANTUNES

PEDRO HENRIQUE ALMEIDA MERLIN

APLICATIVO MOBILE PARA CÁLCULO DE

Trabalho de Conclusão de Curso

DOUGLAS SILVA CRUZ

FELIPE PEREIRA MUNIZ SILVA

INGRID ARRUDA RAMIL DOS SANTOS

MATHEUS RICHARDSON DOS SANTOS ANTUNES

PEDRO HENRIQUE ALMEIDA MERLIN

APLICATIVO MOBILE PARA CÁLCULO DE FLUXO DE POTÊNCIA

Trabalho de Conclusão de Curso apresentado como exigência parcial para

Data da Aprovação: 07/12/2019.

Dedicamos este trabalho de conclusão de curso à todos que nos apoiaram e

Agradecemos a Deus por esta grande realização de estar concluindo o curso de

Também aos Mentores que nos proporcionaram grandes momentos de aprendizado,

“Nossas virtudes e nossos defeitos são inseparáveis, assim como a força e a

No presente trabalho é apresentado o desenvolvimento de um aplicativo

Palavras-chaves: Fluxo de Potência; Sistemas de Potência II; Cálculo de Fluxo de

This academic work presents the development of a didactic application to do the

Figura 1 - Exemplo de rede com 2 barras, uma linha, 2 Capacitores shunt.............................22

Tabela 1 - Dados da rede de 2 barras .........................................................................................30

4.2 Descrição dos Testes da Avaliação do Sistema ..........................................................62

APÊNDICE V – CÓDIGO FONTE DA TELA “RESULTADOS” ................................................116

1.1 Considerações Iniciais

Além de facilitarem a eficiência da compreensão dos aprendizes, também

E, devido à facilidade em acessar aplicativos mobiles, tornaram-se ferramentas

tempo livre, aproveitando os momentos gastos com deslocamento, por exemplo

Por fim, levando-se em conta as abordagens citadas, pode-se concluir que

a) Identificação das necessidades básicas do aplicativo

Foi realizado um levantamento das necessidades de aprendizagem dos alunos

b) Avaliação da metodologia de estudo estático para fluxo de potência de

Nesta etapa foram estudadas as equações que regem o sistema de fluxo de

c) Identificação da tecnologia para elaboração da programação e software

Estudo das tecnologias e protocolos de programação que possibilitam

Nesta parte do trabalho foi elaborado o fluxograma orientativo para realização

e) Implantação e testes do algoritmo

Após o desenvolvimento do algoritmo através de linguagem de programação

Para validar a confiabilidade do aplicativo desenvolvido, foi realizado um

Com o aplicativo estando funcional, foi desenvolvido o sistema de apresentação

1.4 Estado da Arte

Na área acadêmica, foram desenvolvidos programas computacionais para

A tese de mestrado intitulada “Um Programa Interativo para Estudos de Fluxo

O trabalho de graduação (Antunes, 2007) também teve o objetivo de

Os trabalhos apresentados anteriormente têm o intuito de servir como

1.5 Organização do Trabalho

No capítulo 1 foi definido os objetivos deste projeto e a metodologia. Também

No capítulo 2 foi abordado o embasamento teórico para o desenvolvimento do

No capítulo 3 foi descrito a implementação do algoritmo de Newton-Raphson

No capítulo 4 foi apresentada a análise de assertividade do aplicativo através