Sei sulla pagina 1di 61

CLARISSA HATSUE FRANTZ

ROGÉRIO MAUTARITI PIMENTA GOMIDE

INTERFACE PARA SISTEMA DE CONTROLE


DE RELIGADOR AUTOMÁTICO

Projeto apresentado ao curso de


Engenharia Elétrica da Universidade
Federal de Goiás.
Orientador: Prof. Dr. José Wilson Lima
Nerys
Co-orientador: Prof. Dr. Enes Gonçalves
Marra

GOIÂNIA
2003
3

SUMÁRIO

RESUMO........................................................................................... 5

1. INTRODUÇÃO................................................................................. 6

2. PLANEJAMENTO DE UM SISTEMA DE POTÊNCIA............. 8


2.1. TIPOS DE PROTEÇÃO DE SISTEMAS DE POTENCIA .............. 9
2.1.1. Proteção Primária............................................................................. 9
2.1.2. Proteção de Retaguarda................................................................... 10
2.2. CORRENTE DE FALTA................................................................... 11
2.3. PROTEÇÕES MAIS USADAS EM SISTEMAS
ELÉTRICOS................................................................................................... 12
2.3.1. Relé de Sobrecorrente....................................................................... 13
2.3.1.1. Relés de Sobrecorrente Instantâneo................................................... 13
2.3.1.2. Relés de Sobrecorrente de Tempo Definido...................................... 13
2.3.1.3. Relés de Sobrecorrente de Tempo Inverso......................................... 13
2.3.1.4. Relés de Sobrecorrente de Tempo Muito Inverso.......... .................... 14
2.3.1.5. Relés de Religamento......................................................................... 14
4

3. RELIGADOR AUTOMÁTICO....................................................... 14
3.1. DEFINIÇÃO....................................................................................... 14
3.2. PRINCÍPIO DE FUNCIONAMENTO..................................... .......... 15
3.3. CLASSIFICAÇÃO DOS RELIGADORES........................................ 16
3.3.1. Quanto ao número de fases.............................................................. 16
3.3.2. Quanto ao tipo de controle............................................................... 17
3.3.3. Quanto ao meio de interrupção........................................................18
3.4. CRITÉRIO PARA SELEÇÃO DE RELIGADORES.........................19

4. AJUSTES DO RELIGADOR...........................................................21

5. HISTÓRIA DA AUTOMAÇÃO...................................................... 23

6. A IHM (INTERFACE HOMEM – MÁQUINA)............................ 25

7. RS – 232 OU EIA – 232.....................................................................27

8. CONCLUSÃO................................................................................... 31

REFERÊNCIAS BIBLIOGRÁFICAS............................................ 33

ANEXO.............................................................................................. 34
5

RESUMO

Todo sistema de potência deve ser planejado de forma a satisfazer


requisitos mínimos de confiabilidade, que estão diretamente ligados a proteção.

Os religadores são equipamentos de proteção largamente utilizados


para reduzir o tempo de interrupção e aumentar a confiabilidade dos sistemas de
potência; eles permitem o restabelecimento rápido e automático de energia nos
casos de faltas transitórias, como as descargas atmosféricas, contato da rede
elétrica com árvores, ação do vento e contato de animais. A importância dos
religadores fica mais evidente com o resultado de estudos, que revelam que de
50 a 90% das faltas num sistema são de natureza transitória.

Um projeto de pesquisa sobre religadores está em andamento na


Escola de Engenharia Elétrica e trata do controle de religadores usando
processadores digitais de sinais (DSP). O presente projeto de final de curso trata
de uma plataforma DELPHI para monitoramento e controle do projeto em
andamento. A plataforma possibilita o monitoramento e o armazenamento dos
valores das correntes do religador.
6

1. INTRODUÇÃO

O presente relatório tem por objetivo expor o projeto de final de curso


de Engenharia Elétrica, desenvolvido por Clarissa Hatsue Frantz e Rogério
Mautariti Pimenta Gomide.

As linhas aéreas de distribuição estão sujeitas a vários tipos de ações


externas que podem causar interrupções na sua operação. A maior parte delas
são faltas de natureza transitória como descargas atmosféricas, contato de
árvores e animais com a rede elétrica, ação do vento e outras. Para evitar o
desligamento da linha por um tempo muito maior que o necessário, utilizam-se
religadores. Religadores são equipamentos de proteção que desligam e religam
automaticamente os circuitos um número predeterminado de vezes.

O objetivo deste projeto é a implementação de uma plataforma


DELPHI que permitirá o controle e monitoramento de religadores através de
processadores digitais de sinais, além de avaliar o comportamento do sistema de
potência protegido quanto aos níveis de corrente e contribuir para aumentar a
capacidade de coordenação dos religadores de um sistema de distribuição.
7

Esperamos que o produto de nosso trabalho seja utilizado, avaliado e


validado por profissionais da área, para ser eventualmente ajustado as suas reais
necessidades.
8

2. PLANEJAMENTO DE UM SISTEMA DE

POTÊNCIA

Quando iniciamos o planejamento de um sistema devemos levar em


consideração um conjunto de aspectos, a fim de chegar a um arranjo adequado
para a expansão do mesmo (estamos quase sempre expandindo um sistema
existente). Isto significa que novos elementos devem ser compatíveis com
elementos e arranjos já existentes. O planejamento deve conceber um sistema
que seja expansível no futuro e que satisfaça os mínimos requisitos de
confiabilidade a um custo justificável.

Os aspectos econômicos são complexos e representam uma carga


enorme para o projetista. Eliminar um número de dispositivos de proteção é um
meio fácil de reduzir os custos de projeto e, ao mesmo tempo, se distanciar do
ideal e contribuir para um sistema deficiente quanto à confiabilidade.

O engenheiro, ao aplicar dispositivos de proteção, planeja seu esquema


de proteção baseado nos disjuntores disponíveis. È preferível que cada elemento
do circuito (linha, transformador, barra, etc...) possa ser completamente isolado
por seus disjuntores, quando um curto-circuito ocorre no dispositivo,
protegendo, assim, o sistema e facilitando a sua remoção sem maiores
transtornos aos outros dispositivos. Contudo, isto não é sempre possível devido
ao aspecto, já citado, custo. Com a eliminação de disjuntores as zonas de
atuação dos dispositivos de proteção têm que ser aumentadas e passam a incluir
diversos mecanismos do sistema. A desvantagem evidente é devido ao fato de
9

que um defeito em qualquer um dos equipamentos provoca o desligamento de


uma parte maior do sistema do que seria necessário.

A proteção, portanto, desempenha um papel importante num sistema


confiável, e deve ser devidamente considerada ao planejar o sistema. Os
disjuntores e os relés associados devem atuar para proteger o sistema dos efeitos
dos curtos-circuitos nos equipamentos e com o objetivo de minimizar os danos
nos equipamentos com falta.

2.1. TIPOS DE PROTEÇÃO DE SISTEMAS DE


POTÊNCIA

2.1.1. Proteção Primária

A proteção primária funciona como a primeira linha de defesa contra


curtos-circuitos, é um elemento crítico no sistema de potência. Na maioria dos
casos, os relés primários operam dentro de alguns ciclos para iniciar a atuação
do disjuntor e resultam em tempos de limpezas líquidos da ordem de três a sete
ciclos (base de 60Hz). Este tempo de limpeza reduzido é muitas vezes crítico
para estabilidade e sempre crítico quanto à minimização dos danos de falta. É
muito freqüente, o caso em que os tempos de chaveamento críticos são apenas
levemente superiores que os tempos de limpeza da proteção primária. No caso
de falha de uma proteção primária, por ocasião de uma falta severa,
praticamente assegura uma falta de sincronismo. A interrupção no fornecimento
de energia aos consumidores e os danos aos equipamentos, quando o sistema se
10

esfacela devido à instabilidade, são conseqüências que tornam a proteção


primária tão importante.

2.1.2. Proteção de Retaguarda

A proteção de retaguarda, como o próprio nome indica, é instalada


para salvar o sistema no caso de falha da proteção primária. Também, salva a
situação, no caso de falha do disjuntor para limpar curto-circuito detectado pela
proteção primária. Esta definição subentende que a proteção de retaguarda têm
que ser alimenta de TC’s, TP’s e tensão contínua de controle independente da
usada para proteção primária. Além disso, a proteção de retaguarda tem que
disparar disjuntores diferentes daqueles disparados pela proteção primária.

Aspectos econômicos muitas vezes ditam um custo menor para a


proteção de retaguarda. Ao aprofundarmos no estudo da proteção descobriremos
que um custo menor habitualmente implica em relés de maior tempo de
operação. Disso conclui-se que faltas limpadas pelas proteções de retaguarda
resultam em danos de maior vulto e perturbação no sistema do que no caso de
faltas limpadas pela proteção primária (uma parte geral do sistema será
removida de serviço quando opera a retaguarda).

Existem dois tipos de proteção de retaguarda: a proteção de retaguarda


local e a proteção de retaguarda remota.
11

2.2. CORRENTE DE FALTA

A aplicação de dispositivos contra faltas requer conhecimento


detalhado das correntes e tensões que ocorrerão no ponto de aplicação de
qualquer relé durante os curto-circuitos. Deve-se considerar a operação dos relés
durante faltas trifásicas, faltas bifásicas a terra, faltas de fase a fase e faltas de
fase para a terra, bem como todo o tipo de faltas quando incluem impedância de
falta. A resposta dos relés deve ser conhecida para faltas na direção do disparo e
não disparo no caso de relés direcionais.

Todos estes tipos de faltas podem ser calculadas com a ajuda de um


computador. A técnica da matriz impedância de barra é a mais popular e presta-
se ao cálculo rápido de falta em todas as barras, uma vez que a matriz de
impedância tenha sido formada. Uma matriz de impedância da rede de seqüência
positiva permite somente o exame das faltas trifásicas e das faltas fase a fase,
onde as impedâncias de seqüência positiva e negativa podem ser consideradas
iguais. Faltas envolvendo terra podem ser calculadas por essa técnica; contudo, a
matriz impedância de seqüência zero interligadas pelo programa para simular os
tipos de faltas desejadas e suas localizações. Variações no sistema podem ser
representadas por casos alternativos em tal programa. Alternativas típicas que
necessitam freqüentemente ser analisadas são o defeito na barra com uma linha
fora e os casos de falta na extremidade desta linha. Na primeira, as correntes e
tensões de falta em algum ponto do sistema podem variar consideravelmente, se
uma linha está ou não em operação. Considerações quanto ao releamento podem
requerer que os relés tenham um desempenho adequado com ou sem linha e,
assim, essas correntes e tensões de falta devem ser conhecidas em ambos os
casos . Na situação de falta na extremidade da linha , verifica-se que os relés das
12

duas extremidades de uma linha operam simultaneamente. Quando o disjuntor,


numa extremidade de uma linha sob falta, abre antes do disjuntor na
extremidade oposta, pode haver uma mudança significativa na distribuição das
correntes de falta. Esta redistribuição das correntes de falta pode ser de
importância na coordenação dos relés.

2.3. PROTEÇÕES MAIS USADAS EM


SISTEMAS ELÉTRICOS

Os dispositivos de proteção mais usados em sistemas elétricos são:


- relé de sobrecorrente;
- relé de sobrecorrente direcional;
- relé de sobretensão;
- relé de subtensão;
- relé direcional de potência;
- relé de distância;
- relé diferencial;
- de religamento;

Para efeito de proteção, em sistemas de distribuição, são mais


importantes os relés de sobrecorrente e os relés de religamento, que serão aqui
apresentados.
13

2.3.1. Relé de Sobrecorrente

Os relés de sobrecorrente (NEMA-50/51) supervisionam a corrente do


circuito, comandando a abertura de um ou mais disjuntores, quando esta
corrente ultrapassa um valor prefixado. A bobina do relé pode estar ligada
diretamente em série no circuito ou através de um transformador de corrente. Os
relés de corrente, de acordo com os tempos de atuação, podem ser classificados
nos seguintes tipos:

2.3.1.1. Relés de Sobrecorrente Instantâneo

A operação se completa em um intervalo de tempo muito curto, após a


ocorrência de sobrecorrentes, e, praticamente, independe de suas variações. Não
há retardo de tempo propositalmente incluído na seqüência de detecção-
operação. O tipo construtivo que mais se adapta a este modo de operação é o de
atração magnética.

2.3.1.2. Relés de Sobrecorrente de Tempo Definido

O tempo de atuação independe do valor da corrente.

2.3.1.3. Relés de Sobrecorrente de Tempo Inverso

O tempo de operação é inversamente proporcional ao valor da


corrente.
14

2.3.1.4. Relés de Sobrecorrente de Tempo Muito Inverso

São relés que apresentam variações mais acentuadas das


características do tempo com a corrente de atuação.

2.3.1.5. Relés de Religamento

Os relés de religamento (cf.NEMA-79) são relés auxiliares, usados


para comandar o religamento dos disjuntores correspondentes, depois de terem
sido abertos por acionamentos de relés de sobrecorrente. Há possibilidade de
diversas combinações de ordens instantâneas e temporizadas.

3. RELIGADOR AUTOMÁTICO

3.1. DEFINIÇÃO

Religador é um dispositivo interruptor automático, que abre e fecha


seus contatos repetidas vezes na eventualidade de uma falha do circuito por ele
protegido.
15

3.2. PRINCÍPIO DE FUNCIONAMENTO

O religador é um equipamento de proteção a sobrecorrentes utilizado


em circuitos aéreos de distribuição que opera quando detecta correntes de curto-
circuito, desligando e religando automaticamente os circuitos um número
predeterminado de vezes. Quando o religador sente uma sobrecorrente, os
contatos são abertos durante um determinado tempo, chamado tempo de
religamento, após o qual se fecham automaticamente para reenergização da
linha. Se a sobrecorrente persistir, a seqüência de abertura e fechamento dos
contatos é repetida até três vezes consecutivas, e após a quarta abertura, os
contatos ficam abertos e travados.

As operações de um religador podem ser combinadas nas seguintes


seqüências:

a) se for ajustado para quatro operações:


- uma rápida e três retardadas;
- duas rápidas e duas retardadas;
- três rápidas e uma retardada;
- todas rápidas;
- todas retardadas.

b) para qualquer número de operações menor que quatro, em


combinações similares de operações rápidas e retardadas.

Geralmente, os fabricantes fornecem a curva média para uma operação


temporizada do religador com variações de ± 10%. Isto significa que, para uma
16

dada corrente In, o tempo de operação correspondente pode variar sobre uma
reta, de ±10% na base do tempo e ±10% na base da corrente. O maior desvio
será o limite aceitável.

3.3. CLASSIFICAÇÃO DOS RELIGADORES

3.3.1. Quanto ao número de fases

Monofásicos. São utilizados para proteção de linhas monofásicas ou


ramais de alimentação trifásicos (um para cada fase), onde as cargas são
predominantemente monofásicas.

Figura 1: Religador monofásico

Trifásicos. São utilizados onde é necessário o bloqueio das três fases


simultaneamente, para qualquer tipo de falha permanente, a fim de evitar que
cargas trifásicas sejam alimentadas com apenas duas fases. Podem ser:
17

- Trifásicos com Operação Monofásica e Bloqueio Trifásico. São


constituídos de três religadores monofásicos, montados num mesmo tanque,
com os mecanismos interligados apenas para ser processado o bloqueio trifásico.
Cada fase opera independentemente em relação às correntes de defeito.

Se qualquer das fases operar o número pré-ajustado para bloqueio, as duas


outras fases são abertas e bloqueadas através do mecanismo que as interliga.

- Trifásicos com Operação Trifásica e Bloqueio Trifásico. São


constituídos de um único religador, que opera e bloqueia sempre trifasicamente,
independentemente do tipo de falha ocorrida, isto é, mesmo que a falha afete
apenas uma das fases, todos os contatos realizam a operação de abertura e
religamento.

Figura 2: Religador trifásico

3.3.2. Quanto ao tipo de controle

Controle Hidráulico. Nos religadores com este tipo de controle, as


correntes são detectadas pelas bobinas de disparo que estão em série com a
linha. Quando, através da bobina, flui uma corrente igual ou superior à corrente
mínima de disparo do religador, o núcleo da bobina é atraído para seu interior,
18

provocando a abertura dos contatos principais do religador. O sistema de


controle hidráulico é econômico e simples, eficiente e de grande vida útil. Essas
características são extremamente importantes para áreas de baixa densidade de
carga ou para outras áreas que não requeiram níveis de precisão acentuados na
operação do equipamento, corrente de disparo muito pequenas, tanto para fase,
como para neutro, ou grande velocidade na interrupção.

Controle Eletrônico. Com este tipo de controle, o religamento


apresenta maior flexibilidade e mais facilidade para ajustes e ensaios, além de
ser mais preciso, comparativamente ao de controle hidráulico. Contudo, essas
vantagens devem ser economicamente avaliadas antes de ser procedida a escolha
entre um religador com controle hidráulico e um com controle eletrônico.

O controle eletrônico é abrigado numa caixa separada do religador e


permite as seguintes modificações de ajustes no equipamento, sem que seja
necessário sua abertura:

-característica tempo x corrente;


-níveis de corrente de disparo;
-seqüência de operação.

3.3.3. Quanto ao meio de interrupção

Quanto ao meio de interrupção, os religadores se classificam em:


19

-religadores com interrupção a óleo;


-religadores com interrupção a vácuo.

Os religadores do segundo tipo apresentam possibilidade de período de


trabalho de cerca de 3 a 4 vezes o do primeiro tipo, entre manutenções. Contudo,
as garrafas de vácuo que substituem o óleo são importadas e seu uso deve ser
economicamente avaliado.

3.4. CRITÉRIO PARA SELEÇÃO DE


RELIGADORES

Para a seleção de religadores , devem ser levados em conta os


seguintes requisitos:

1. A corrente nominal do equipamento deve ser superior à máxima


corrente do alimentador, convenientemente medida ou avaliada na situação de
maior carga do circuito, e deve prever aumentos futuros de carga.

2. A tensão nominal deve ser compatível com a do sistema.

3. A capacidade de interrupção deve ser maior que a máxima corrente


de curto-circuito, trifásica ou fase-terra, calculada no ponto de sua instalação.

4. A corrente de curto-circuito máxima simétrica no ponto de


instalação deve ser menor do que a corrente de interrupção simétrica do
religador correspondente ao valor X/R no ponto. Quando não se dispõe desses
20

dados do fabricante, é prática usual adotar, para comparação, o valor simétrico


único por ele fornecido.

5. As correntes de disparo devem ser menores do que as correntes de


curto-circuito na zona de proteção do equipamento, incluindo, sempre que
possível, os trechos a serem adicionados quando se realizarem manobras
consideradas usuais.

6. A temporização deve possibilitar a coordenação com outros


equipamentos de proteção a justante e a montante.

7. A corrente nominal da bobina-série, no caso de religador, deve ser


dimensionada de acordo com a corrente máxima do alimentador, incluindo
manobras usuais, e com previsão de crescimento de carga, sempre que possível.

8. A bobina de fechamento, no caso de religador, deve ter tensão


nominal igual à tensão entre as fases do circuito.

9. O nível de isolamento deve ser compatível com o do sistema.

10. A freqüência deve ser compatível com a do sistema.

Quanto à proteção de falhas fase-terra, para o caso de sistemas não-


efetivamente-aterrados, como as correntes de curto-circuito fase-terra
apresentam intensidades muito pequenas, é recomendado o uso de dispositivos
eletrônicos para disparo do neutro. Esse dispositivo, normalmente, é composto
dos seguintes elementos: transformador de corrente, bobina de disparo e circuito
eletrônico de disparo.
21

A corrente mínima de disparo do dispositivo é determinada pelo valor


de um resistor, o qual deve ser especificado de modo que a referida corrente seja
menor que o curto-circuito fase-terra mínimo calculado.

Os tempos de operação do dispositivo (operação rápida e operação


retardada) são determinados por capacitores.

No caso de sistema efetivamente aterrados, são usados dispositivos de


sobrecorrente apropriados ao equipamento.

Para o caso de sistema com o neutro isolado, é recomendável o uso de


dispositivo de proteção defeito fase-terra baseado na tensão residual. Esse
dispositivo é composto dos seguintes elementos: transformadores de potencial
monofásicos e bobinas de disparo. É recomendável, ainda, a utilização da chave
auxiliar, para isolamento da bobina de disparo, quando os contatos do religador
estiverem abertos, e da chave de bloqueio, para tornar inoperante a bobina de
disparo antes do fechamento manual do religador.

4. AJUSTES DO RELIGADOR

Os religadores instalados em subestações devem ser ajustados de modo


a atender os seguintes requisitos:

a) Ajuste de Disparo de Fase. A corrente mínima de disparo de fase do


religador deve ser menor que a corrente mínima de defeito fase-fase, dentro da
22

zona de proteção do religador, incluindo, sempre que possível, os trechos a


serem adicionados quando forem realizadas as manobras.

b) Ajuste de Disparo de Neutro. A corrente mínima de disparo de


neutro do religador deve ser menor que a corrente de defeito fase-terra mínimo,
dentro da zona de proteção do religador, e deve der maior que a máxima
corrente de desbalanço para o neutro.

c) Característica Tempo x Corrente (Fase e Neutro). Esta característica


deve atender aos seguintes requisitos:

- a curva de operação do religador para toda a faixa de valores de


curto-circuito deve estar sempre abaixo da curva de dano dos condutores e
equipamentos do circuito para as mesmas correntes;

- a curva escolhida deve permitir a coordenação com equipamentos


de proteção situados a montante e a justante.

d) Seqüência de Operação. A seqüência de operação deve ser definida


de modo a permitir a coordenação seletiva dos equipamentos de proteção ao
longo do circuito.

e) Tempo de Religamento. Deve ser ajustado, de modo a permitir


coordenação com equipamentos de proteção situados a montante e a justante,
cuja operação depende desse tempo.
23

Obs.: Nos religadores com controle hidráulico, a corrente mínima de


operação de fase e a característica tempo x corrente de disparo de fase dependem
exclusivamente da bobina-série.

5. HISTÓRIA DA AUTOMAÇÃO

Desde os primórdios que o homem vem utilizando a sua criatividade


para desenvolver instrumentos que o ajudassem a controlar e modificar o meio
ambiente em que está inserido, melhorando assim, sua condição de vida. Com o
decorrer da história, compreendeu-se que a criação de novos mecanismos
pudesse substituir o processo produtivo artesanal, poderiam ser chaves para o
sucesso e possibilitaria o alcance de seus objetivos de forma rápida e econômica.
Com essa nova meta traçada e com a promessa pautada na melhoria da
qualidade de vida e liberação do ser humano da mão de obra braçal , é que em
meados do século XVIII , foram desenvolvidas as primeiras máquinas que
acabaram dando suporte tecnológico para a primeira revolução industrial.

Essa primeira revolução industrial, também conhecida como revolução


da máquina, ocorreu na Inglaterra, mais precisamente no período de 1760 a
1850, foi caracterizada pela transição de um processo predominantemente
agrícola de subsistência e da produção de bens e consumo para uma sociedade
industrializada , caracterizada pela introdução de máquina simples , para
substituição da força muscular pela mecânica , em tarefas repetidas, antes
executadas pelo homem .
24

A segunda revolução industrial se deu com aperfeiçoamento e


implantação das máquinas por toda a Europa no período de 1850 a 1900, foi
caracterizado por um grande avanço na tecnologia, onde apareceram a
locomotiva a vapor e o barco a vapor. O primeiro trabalho significativo, ocorreu
neste período, foi James Watt, que construiu, no século XVIII, um controlador
centrifugo para o controle de velocidade de uma máquina a vapor.

A automação nasceu da necessidade de aumento de flexibilização,


maior rapidez na produção e redução de custos das empresas de manufatura ou
de processo contínuo , afim de que pudessem se adequar rapidamente às
necessidades do consumidor e assim manter-se competitivo no mercado cada
vez mais exigente .

A automação industrial tem desempenhado um papel vital no avanço


da engenharia e da ciência. Além de sua extrema importância para veículos
espaciais, para sistema de guiamento de mísseis e sistema de robótica e
similares. O controle automático tornou-se uma parte importante e integrante
dos processos industriais e de manufatura modernos. Por exemplo, a automação
industrial é essencial no comando numérico de máquinas-ferramentas das
indústrias manufatureiras, no projeto de sistemas de pilotagem automática da
indústria aeroespacial e no projeto de automóveis e caminhões da indústria
automobilística. É ainda essencial nas operações industriais tais como: controle
de pressão, temperatura, umidade, viscosidade e vazão nas indústrias de
processo.

Considerando que os avanços na teoria e na prática na automação


industrial propiciam meios para se atingir desempenho ótimo de sistemas
dinâmicos, melhoria da produtividade , alívio no trabalho enfadonho de muitas
25

operações manuais repetitivas de rotina e muito mais , os engenheiros e


cientistas , em sua maioria , devem possuir agora um bom conhecimento deste
campo.

Foi pensando nesses aspectos e com intenções similares que


executamos este projeto, que se trata da automatização e supervisão do
desempenho de um dispositivo de proteção de sistemas de transmissão de
potência, conhecido como “religador”. O projeto tem como objetivo aperfeiçoar
o processo de atuação da proteção digitalizando o dispositivo que, em tempos
passados, era composto por um mecanismo eletro-mecânico.

6. A IHM (INTERFACE HOMEM - MÁQUINA)

A interface faz parte do sistema computacional e determina como as


pessoas operam e controlam o sistema. Quando a interface é bem projetada, ela
é compreensível, agradável e controlável; os usuários se sentem satisfeitos e
responsáveis pelas ações.

É fácil notar a importância do assunto, pois todos somos usuários de


interfaces. Às vezes utilizamos sistemas e nem lembramos que existe uma
interface, outras vezes, tudo que se quer é encontrar o botão de sair.

A interface homem-máquina é uma preocupação da indústria muito


antes de se falar em interface de programas de computador. Existe muita
experiência adquirida sobre o assunto, como por exemplo à utilização de mais
26

de um perfil do operador (usuário) e níveis de conhecimento ou experiência


(iniciante, intermediário e expert).

A tecnologia de construção de interfaces tem sido influenciada


principalmente pelos seguintes fatores:

a. Disseminação do uso de sistemas e equipamentos


microprocessados;

b. Aumento da complexidade dos sistemas;

c. Preocupação com a qualidade do software dentro da característica


de usabilidade (conforme as definições da Norma ISO/IEC 9126-1).

O Projeto de Interface resulta de uma análise mais detalhada da


mesma. Essa análise pode se dar através da especificação de requisitos, módulo
de qualidades e perfil dos usuários. Nessa fase normalmente se considera a
modelagem do diálogo (onde se encontra o projeto visual) e a modelagem
dinâmica (tratamento dos eventos).

No início do processamento de dados, distingue-se basicamente as


interfaces baseadas em caracteres. Atualmente, a maioria das aplicações se
utilizam das famosas interfaces gráficas – GUI (Graphical User Interface ) e
algumas já estão evoluindo o conceito deixando de ser voltadas a aplicação para
se tornarem voltadas a objeto, utilizando as OUI ( Object User Interface ) e,
paralelamente, com a crescente utilização da Internet, surgiram as WUI ( Web
User Interface ) amplamente difundidas dentro da World Wide Web.

Todas essas amostras de interfaces são apenas uma pequena


demonstração do desenvolvimento que ainda está por vir, ainda mais,
27

considerando-se a crescente demanda por utilização de recursos de multimídia –


a integração de textos, som (música, voz e ruído) e imagem (real, digitalizada,
sintetizada; estática ou em movimento).

A interface foi o grande desafio deste projeto, pensando nas


afirmações anteriores,construímos um software sob a plataforma Borland
Delphi, versão 5, onde o ambiente principal é de fácil visualização e interação
com o usuário, permitindo supervisionar o funcionamento do religador, assim
como inicializar e desligar o programa. É possível a visualização das correntes
IA, IB, IC e IN, das tensões VA, VB e VC, status da RS 232 e status de alarme. Há
também o nível de configuração, que é acessado apenas com senha, e nos mostra
32 itens que são parâmetros de controle do relé que atua sobre o religador e
fazem parte da fórmula da curva de operação. Outro nível é o de resultados que
nos mostra gráficos e permite obter relatórios.

7. RS - 232 ou EIA - 232

Características principais:

• A interface RS 232, estabelecida pela EIA ( Eletronic Industries


Association ), é um padrão de interface física que define a conexão mecânica,
funcional e elétrica para transmissão serial de dados.

• Velocidades típicas de 38.4 Kbps, 115,2 Kbps;


28

• É utilizada para transmissões entre equipamentos separados por


uma distância de até 15 metros.

• É o padrão n\mais comum utilizado pelos fabricantes de


equipamentos para informática e telecomunicações;

• Sinais de tensão não balanceadas: o valor limite oscila entre -


25V a + 25V, sendo o seu padrão de +/-12V.

As transmissões de dados de eletrônicos entre elementos cairão


geralmente em duas categorias largas: single-ended e diferencial. RS232 (single-
ended) foi introduzido em 1962, e apesar dos boatos que levaram a sua redução
de uso adiantada, continuou sendo usada extensamente na indústria.

Os intervalos de dados da RS232 são: +3 A +12 volts bipolares


indicam “on”1-state (MARCA), quando A -3 a -12 volts indicam uma condição
de "off"0-state (ESPAÇO). O equipamento de computador moderno ignora o
nível negativo e aceita um nível de tensão zero como o estado de "off". De fato,
o estado de "on” pode ser conseguido com pouco potencial positivo. Isto
significa que os circuitos alimentados por 5 VDC são capazes de dirigir os
circuitos RS232.
29

O nível do sinal de saída oscila geralmente entre +12V e -12V. A “área


inoperante" entre +3v e -3v é projetada para absorver o ruído de linha. Nas
várias definições de RS-232 esta área inoperante pode variar. Por exemplo, a
definição para V.10 tem uma área inoperante de +0.3v a -0.3v. Muitos
receptores projetados para RS-232 são sensíveis aos diferenciais de 1v ou
menos.

Nota: Para transmitir e receber ligações os pinos (2 ou 3) podem ser


invertidos dependendo do uso do equipamento - equipamento de transmissões de
dados (DCE) ou um equipamento terminal de dados (DTE).

Utilizamos transmissão serial com RS 232 através do programa


ASYNC 32 do DELPHI.
30

O programa ASYNC 32 é um componente, pertencente ao DELPHI,


que controla o buffer de transmissão serial permitindo, assim, o gerenciamento
do controle do fluxo de dados de acordo com as necessidades do usuário.
31

8. CONCLUSÃO

Com o presente projeto adquirimos um maior conhecimento sobre o


funcionamento de dispositivos de proteção, principalmente religadores,
transmissão serial, usando interface RS 232 e linguagem de programação
orientada a objeto, Delphi.

Conseguimos implementar a plataforma que nos possibilita o


monitoramento do religador, a transmissão dos parâmetros de configuração do
controlador e a emissão de relatórios. Isso foi conseguido pelo controle do
buffer de transmissão serial (RS 232) pelo componente ASYNC32, existente no
Delphi.

Ao final do trabalho ficamos ainda curiosos em saber como teria sido o


controle de dados se o controlador estivesse em serviço, pois este não teria
dispositivos de transmissão praticamente prontos em sua configuração e, então,
necessitaríamos da aquisição de protocolos de comunicação, para segurança no
tráfego de dados.
32

Terminamos gratos com o trabalho pois ele nos deu uma visão prática
da viabilidade de estarmos aplicando nossos conhecimentos, adquiridos na
Escola de Engenharia Elétrica UFG, em atividades e processos rotineiros
tentando, assim, aperfeiçoá-los.
33

REFERÊNCIAS BIBLIOGRÁFICAS

1. CAMINHA, Amadeu Casal. Introdução à Proteção dos Sistemas


Elétricos. São Paulo. 1977. Ed. Edgard Blücher LTDA.

2. CLARK, Harrison K. Proteção de Sistemas Elétricos de Potência. Santa


Maria. 1979. Universidade Federal de Santa Maria.

3. ELETROBRÁS. Comitê de Distribuição. Proteção de Sistemas Aéreos de


Distribuição. Rio de Janeiro. 1982. Vol. 2. Eletrobrás.

4. FLUCKIGER, François. Understanding Network Multimedia.


34

ANEXO
35

PROGRAMA

unit Principal;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, CommInt, ExtCtrls, Mask, Buttons, VaClasses, VaComm, jpeg,
ComCtrls, Psock, NMFtp;

type
TfrmPrincipal = class(TForm)
sbtConfig: TSpeedButton;
sbtResultados: TSpeedButton;
sbtConectar: TSpeedButton;
sbtDesconectar: TSpeedButton;
Timer: TTimer;
Comm1: TComm;
mStatus: TMemo;
sbtSair: TSpeedButton;
Label1: TLabel;
editCorB: TEdit;
editCorA: TEdit;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
editFaseC: TEdit;
editCorC: TEdit;
editFaseB: TEdit;
editFaseA: TEdit;
editCorN: TEdit;
Image1: TImage;
Label8: TLabel;
Panel1: TPanel;
StatusBar1: TStatusBar;
NMFTP1: TNMFTP;
StatusBar2: TStatusBar;
procedure sbtConectarClick(Sender: TObject);
procedure sbtDesconectarClick(Sender: TObject);
procedure sbtSairClick(Sender: TObject);
procedure Comm1Break(Sender: TObject);
procedure TimerTimer(Sender: TObject);
procedure Comm1RxChar(Sender: TObject; Count: Integer);
36

procedure FormCreate(Sender: TObject);


procedure sbtResultadosClick(Sender: TObject);
procedure sbtConfigClick(Sender: TObject);

private
{ Private declarations }
public
{ Public declarations }
end;

var

frmPrincipal: TfrmPrincipal;
tempo: TTime;
FlagFechado: byte;
NumByte,ia,ib,ic,ineutro,fa,fb,fc: integer;
msg,via,vib,vic,vin,vfa,vfb,vfc,vtp: string;
mia,mib,mic,min,mfa,mfb,mfc,tp: array[1..1000] of integer;

implementation

uses Resultados, Configuracao;

{$R *.DFM}

procedure AlarmeA(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto, 'Sobrecorrente na fase A' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end
else
begin
37

assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm


"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobrecorrente na fase A' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;

procedure AlarmeB(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto, 'Sobrecorrente na fase B' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end
else
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobrecorrente na fase B' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;
38

procedure AlarmeC(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto, 'Sobrecorrente na fase C' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end
else
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobrecorrente na fase C' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;

procedure AlarmeN(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto, 'Sobrecorrente no neutro' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end
39

else
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobrecorrente no neutro' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;

procedure AlarmeVa(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto, 'Sobretensão na fase A' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end
else
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobretensão na fase A' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;
40

procedure AlarmeVb(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto, 'Sobretensão na fase B' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end
else
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobretensão na fase B' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;

procedure AlarmeVc(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
41

writeln(texto, 'Sobretensão na fase C' + FormatDateTime('hh:mm:ss',now) +


frmPrincipal.editCorB.Text);
Closefile(texto);
end
else
begin
assignfile(texto,concat('c:\Resultados.\Alarmes - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'HISTÓRICO DOS ALARMES');
writeln(texto);
writeln(texto);
writeln(texto, 'Tipo de Falta' + 'Horário' + 'Valor da Falta');
writeln(texto, 'Sobretensão na fase C' + FormatDateTime('hh:mm:ss',now) +
frmPrincipal.editCorB.Text);
Closefile(texto);
end;
end;

procedure SalvarArquivo(s:string);
var
texto: text;
begin
CreateDir('c:\Resultados.');
If FileExists(concat('c:\Resultados.\Entradas - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt')) then
begin
assignfile(texto,concat('c:\Resultados.\Entradas - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Append(texto);
writeln(texto,s);
Closefile(texto);
end
else
begin
assignfile(texto,concat('c:\Resultados.\Entradas - ',FormatDateTime('dddd, d "de" mmmm
"de" yyyy',date),'.txt'));
Rewrite(texto);
writeln(texto,'LEGENDA');
writeln(texto);
writeln(texto,'Ia: Corrente na fase A');
writeln(texto,'Ib: Corrente na fase B');
writeln(texto,'Ic: Corrente na fase C');
writeln(texto,'In: Corrente no neutro');
writeln(texto,'Va: Tensão na Fase A');
writeln(texto,'Vb: Tensão na fase B');
42

writeln(texto,'Vc: Tensão na fase C');

writeln(texto,'_____________________________________________________');
writeln(texto,'Horário Ia Ib Ic In Va Vb Vc ');
writeln(texto,'_____________________________________________________');
writeln(texto,s);
Closefile(texto);
end;
end;

procedure TfrmPrincipal.sbtConectarClick(Sender: TObject);


begin
Comm1.Open;
FlagFechado := 0;
tempo:=0;
sbtConectar.Enabled := false;
sbtDesconectar.Enabled := true;
mStatus.Lines.Add(' Porta pronta: ' + Comm1.DeviceName);
mStatus.Lines.Add(' ' +FormatDateTime('hh:mm:ss',tempo ));
StatusBar1.Panels.Items[0].Text := 'Conectado - COM1';
Timer.Enabled:=true;
end;

procedure TfrmPrincipal.sbtDesconectarClick(Sender: TObject);


begin
Comm1.Close;
FlagFechado := 1;
sbtConectar.Enabled := true;
sbtDesconectar.Enabled := false;
mStatus.Lines.Add(' Porta fechada: ' + Comm1.DeviceName);
StatusBar1.Panels.Items[0].Text := 'Desconectado ';
Timer.Enabled:=false;
end;

procedure TfrmPrincipal.sbtSairClick(Sender: TObject);


begin
if Application.MessageBox('Tem certeza que deseja sair?','Confirmação',
MB_IconQuestion + MB_YesNo) = idYes
then
Close;
43

end;

procedure TfrmPrincipal.Comm1Break(Sender: TObject);


begin
showmessage('A conexão foi perdida!');
end;

procedure TfrmPrincipal.TimerTimer(Sender: TObject);


begin
mStatus.Lines.Add(' ' + FormatDateTime('hh:mm:ss',now));
StatusBar1.Panels.Items[1].Text := FormatDateTime('hh:mm:ss ',now);
end;

procedure TfrmPrincipal.Comm1RxChar(Sender: TObject; Count: Integer);


type
CharBuf = array[0..9999] of Char;
var
Buffer: ^CharBuf;
Bytes, P: Integer;
begin
If FlagFechado = 0 then // Conferir evento RXChar durante Close !
Begin
GetMem(Buffer, Comm1.ReadBufSize);
try
Fillchar(Buffer^, Comm1.ReadBufSize, 0);
Bytes := Comm1.Read(Buffer^, Count);
if Bytes = -1 then
mStatus.Lines.Add('Erro ao ler o sinal' + Comm1.DeviceName)
else
begin
mStatus.Lines.Add(' Total de byte(s) recebido(s): ' + inttostr(bytes));
for P := 0 to Bytes - 1 do
begin
NumByte := NumByte + 1;
Case NumByte of
1: Begin
ia := ia +1;
editCorA.Text := floattostr(integer(CharBuf(Buffer^)[P]));
mia[ia] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar1.Text)then
StatusBar2.Panels.Items[0].Text := 'ALARME: Sobrecorrente na fase A';
AlarmeA(msg);
44

end
end;
2: Begin
ib := ib +1;
editCorB.Text := floattostr(integer(CharBuf(Buffer^)[P]));
mib[ib] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar2.Text)then
StatusBar2.Panels.Items[0].Text := 'ALARME: Sobrecorrente na fase B';
AlarmeB(msg);
end
end;
3: Begin
ic := ic +1;
editCorC.Text := floattostr(integer(CharBuf(Buffer^)[P]));
mic[ic] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar3.Text)then
AlarmeC(msg);
StatusBar2.Panels.Items[0].Text := 'ALARME: Sobrecorrente na fase C';
end
end;
4: Begin
ineutro := ineutro +1;
editCorN.Text := floattostr(integer(CharBuf(Buffer^)[P]));
min[ineutro] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar4.Text)then
AlarmeN(msg);
StatusBar2.Panels.Items[0].Text := 'ALARME: Sobrecorrente no neutro';
end
end;
5: Begin
fa := fa +1;
editFaseA.Text := floattostr(integer(CharBuf(Buffer^)[P]));
mfa[fa] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar5.Text)then
AlarmeVa(msg);
StatusBar2.Panels.Items[0].Text := 'ALARME: Subtensão na fase A';
end
end;
6: Begin
fb := fb +1;
editFaseB.Text := floattostr(integer(CharBuf(Buffer^)[P]));
mfb[fb] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar6.Text)then
StatusBar2.Panels.Items[0].Text := 'ALARME: Subtensão na fase B';
AlarmeVb(msg);
end
end;
7: Begin
45

fc := fc +1;
editFaseC.Text := floattostr(integer(CharBuf(Buffer^)[P]));
mfc[fc] := integer(CharBuf(Buffer^)[P]);
Begin if mia[ia] > integer(frmConfiguracao.editPar7.Text)then
AlarmeVc(msg);
StatusBar2.Panels.Items[0].Text := 'ALARME: Subtensão na fase C';
end
end;
end;
msg := concat(msg,' ',inttostr(integer(CharBuf(Buffer^)[P])));
If NumByte = 7 then
Begin
msg := concat(FormatDateTime('hh"h"mm"m"ss"s"',now),' ',msg);
SalvarArquivo(msg);
msg := '';
NumByte := 0;
end;
end; //Fim do For
end;
Application.ProcessMessages;
finally
FreeMem(Buffer);
end;
end;
end;

procedure TfrmPrincipal.FormCreate(Sender: TObject);


begin
NumByte := 0;
ia:=0; ib:=0; ib:=0; ineutro:=0; fa:=0; fb:=0; fc:=0;
msg := ''; via:='';vib:='';vic:='';vin:='';vfa:='';vfb:='';vfc:='';vtp:='';
Comm1.Close;
FlagFechado := 1;
tempo := 0;
ia:=0;
ib:=0;
ic:=0;
ineutro:=0;
fa:=0;
fb:=0;
fc:=0;
sbtDesconectar.Enabled := false;
editCorA.Text:= '';
editCorB.Text:= '';
editCorC.Text:= '';
editFaseA.Text:= '';
editFaseB.Text:= '';
46

editFaseC.Text:= '';
editCorN.Text:= '';
mStatus.Lines.Add('' + FormatDateTime('hh:mm:ss',tempo));
Timer.Enabled:=false;
end;

procedure TfrmPrincipal.sbtResultadosClick(Sender: TObject);


begin
If FileExists(concat('c:\Resultados.\Entradas - ',FormatDateTime('dddd, d "de" mmmm "de"
yyyy',date),'.txt'))
then
Begin
frmResultados.show;
frmResultados.sbtRelatorio.Enabled := true;
frmResultados.editResultados.Lines.LoadFromFile(concat('c:\Resultados.\Entradas -
',FormatDateTime('dddd, d "de" mmmm "de" yyyy',date),'.txt'));
end
else
showmessage('Os dados não foram recebidos!');
end;

procedure TfrmPrincipal.sbtConfigClick(Sender: TObject);


var
senha: string;
begin
senha := '';
if InputQuery('Senha', 'Digite a senha:', senha) then
begin
if senha = frmConfiguracao.editParSenha.Text then frmConfiguracao.Show
else showmessage('Senha incorreta!');
end;
end;

end.

unit Resultados;

interface

uses
47

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,


StdCtrls, Buttons, TeEngine, Series, ExtCtrls, TeeProcs, Chart, ComObj,jpeg,
ComCtrls;

type
TfrmResultados = class(TForm)
chartCorA: TChart;
sbtRelatorio: TBitBtn;
sbtSairII: TBitBtn;
editResultados: TMemo;
sbtSalvar: TBitBtn;
BitBtn1: TBitBtn;
sbtEditar: TButton;
sbtReset: TButton;
chartCorC: TChart;
Chart3: TChart;
Chart4: TChart;
Chart5: TChart;
Chart1: TChart;
Series3: TLineSeries;
Series1: TLineSeries;
Series4: TLineSeries;
Series5: TLineSeries;
Series6: TLineSeries;
Series7: TLineSeries;
Chart2: TChart;
Series2: TLineSeries;
procedure sbtSairIIClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure sbtSalvarClick(Sender: TObject);
procedure sbtRelatorioClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
frmResultados: TfrmResultados;

implementation

uses Principal;

{$R *.DFM}

procedure TfrmResultados.sbtSairIIClick(Sender: TObject);


48

begin
Close;
end;

procedure TfrmResultados.FormShow(Sender: TObject);


var a: integer;
Begin
tp[1] := 0;
For a := 2 to ia do
Begin
tp[a] := tp[a-1] + 1;
via := concat(vtp,' ',inttostr(tp[a]));
end;
With Series1 do
Begin
For a := 1 to ic do
Begin
AddXY(tp[a],mic[a]);
vic := concat(vic,' ',inttostr(mic[a]));
end;
end;
With Series2 do
Begin
For a := 1 to ib do
Begin
AddXY(tp[a],mib[a]);
vib := concat(vib,' ',inttostr(mib[a]));
end;
end;
With Series3 do
Begin
For a := 1 to ia do
Begin
AddXY(tp[a],mic[a]);
via := concat(via,' ',inttostr(mia[a]));
end;
end;
With Series4 do
Begin
For a := 1 to ineutro do
Begin
AddXY(tp[a],min[a]);
vin := concat(vin,' ',inttostr(min[a]));
end;
end;
With Series5 do
49

Begin
For a := 1 to fa do
Begin
AddXY(tp[a],mfa[a]);
vfa := concat(vfa,' ',inttostr(min[a]));
end;
end;
With Series6 do
Begin
For a := 1 to fb do
Begin
AddXY(tp[a],mfb[a]);
vfb := concat(vfb,' ',inttostr(min[a]));
end;
end;
With Series7 do
Begin
For a := 1 to fc do
Begin
AddXY(tp[a],mfc[a]);
vfc := concat(vfc,' ',inttostr(min[a]));
end;
end;
end;

procedure TfrmResultados.sbtSalvarClick(Sender: TObject);


var
texto: TextFile;
cont :integer;
Begin
cont := 1;
If FileExists(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.m')) then
Begin
While FileExists(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.m')) do
cont := cont + 1;
assignfile(texto,concat('c:\Resultados.\Entradas - ',inttostr(cont),'.m'));
Rewrite(texto);
writeln(texto,concat(char(#37),'Universidade Federal de Goiás - Núcleo PEQ'));
writeln(texto,concat(char(#37),'Criado em ',FormatDateTime('dd "de" mmmm "de"
yyyy',date),' às ',FormatDateTime('hh"h"mm"m"ss"s"',now)));
writeln(texto,concat(char(#37),'Autores:'));
writeln(texto,concat(char(#37),' Rogério Gomide - rogeriogomide@ig.com.br'));
writeln(texto,concat(char(#37),' Clarissa Hatsue - clarissa_frantz@ig.com.br'));
writeln(texto,'');
writeln(texto,concat('Ia=[',via,'];'));
writeln(texto,concat('Ib=[',vib,'];'));
50

writeln(texto,concat('Ic=[',vic,'];'));
writeln(texto,concat('In=[',vin,'];'));
writeln(texto,concat('Va=[',vfa,'];'));
writeln(texto,concat('Vb=[',vfb,'];'));
writeln(texto,concat('Vc=[',vfc,'];'));
Closefile(texto);
end
else
Begin
assignfile(texto,concat('c:\Resultados.\Entradas - ','.m'));
Rewrite(texto);
writeln(texto,concat(char(#37),'Universidade Federal de Goiás - Núcleo PEQ'));
writeln(texto,concat(char(#37),'Criado em ',FormatDateTime('dd "de" mmmm "de"
yyyy',date),' às ',FormatDateTime('hh"h"mm"m"ss"s"',now)));
writeln(texto,concat(char(#37),'Autores:'));
writeln(texto,concat(char(#37),' Rogério Gomide - rogeriogomide@ig.com.br'));
writeln(texto,concat(char(#37),' Clarissa Hatsue - clarissa_frantz@ig.com.br'));
writeln(texto,'');
writeln(texto,concat('Ia=[',via,'];'));
writeln(texto,concat('Ib=[',vib,'];'));
writeln(texto,concat('Ic=[',vic,'];'));
writeln(texto,concat('In=[',vin,'];'));
writeln(texto,concat('Va=[',vfa,'];'));
writeln(texto,concat('Vb=[',vfb,'];'));
writeln(texto,concat('Vc=[',vfc,'];'));
Closefile(texto);
end;
editResultados.Lines.SaveToFile(concat('c:\Resultados.\Entradas - ',FormatDateTime('dddd, d
"de" mmmm "de" yyyy',date),'.txt'));
editResultados.ReadOnly := true;
editResultados.TabStop := false;
end;

procedure TfrmResultados.sbtRelatorioClick(Sender: TObject);


var
Excel: variant;
Linha,cont:Integer;
begin
cont := 1;
Excel := CreateOleObject('Excel.Application');
If FileExists(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.xls')) then
Begin
while FileExists(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.xls')) do
cont := cont +1;
Excel.Workbooks.Add;
51

Excel.Workbooks[1].Sheets[1].Name := 'Vetores';
Excel.Workbooks[1].Sheets[1].Cells[1,1] := 'VALORES:';
Excel.Workbooks[1].Sheets[1].Cells[1,2] := Datetostr(Now);
Excel.Workbooks[1].Sheets[1].Cells[1,3] := Timetostr(Now);
Excel.Workbooks[1].Sheets[1].Cells[3,1] := 'Corrente';
Excel.Workbooks[1].Sheets[1].Cells[3,2] := 'Horário';
For Linha := 1 to ia do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,1] := mia[Linha];
For Linha := 1 to ia do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,2] :=
Timetostr(Now);
Excel.Workbooks[1].SaveAs(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.xls'));
Excel.Workbooks[1].Close;

Begin
while FileExists(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.xls')) do
cont := cont +1;
Excel.Workbooks.Add;
Excel.Workbooks[1].Sheets[1].Name := 'Vetores';
Excel.Workbooks[1].Sheets[1].Cells[1,1] := 'VALORES:';
Excel.Workbooks[1].Sheets[1].Cells[1,2] := Datetostr(Now);
Excel.Workbooks[1].Sheets[1].Cells[1,3] := Timetostr(Now);
Excel.Workbooks[1].Sheets[1].Cells[3,1] := 'Corrente Fase A';
Excel.Workbooks[1].Sheets[1].Cells[3,2] := 'Corrente Fase B';
Excel.Workbooks[1].Sheets[1].Cells[3,3] := 'Corrente Fase C';
Excel.Workbooks[1].Sheets[1].Cells[3,4] := 'Corrente Neutro';
Excel.Workbooks[1].Sheets[1].Cells[3,5] := 'Tensão Fase A';
Excel.Workbooks[1].Sheets[1].Cells[3,6] := 'Tensão Fase B';
Excel.Workbooks[1].Sheets[1].Cells[3,7] := 'Tensão Fase C';
Excel.Workbooks[1].Sheets[1].Cells[3,8] := Timetostr(Now);
For Linha := 1 to ia do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,1] := mia[Linha];
For Linha := 1 to ib do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,2] := mib[Linha];
For Linha := 1 to ic do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,3] := mic[Linha];
For Linha := 1 to ineutro do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,4] :=
min[Linha];
For Linha := 1 to fa do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,5] := mfa[Linha];
For Linha := 1 to fb do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,6] := mfb[Linha];
For Linha := 1 to fc do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,7] := mfc[Linha];
For Linha := 1 to ia do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,8] :=
Timetostr(Now);
Excel.Workbooks[1].SaveAs(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.xls'));
Excel.Workbooks[1].Close;
end
end
else
Begin
Excel.Workbooks.Add;
Excel.Workbooks[1].Sheets[1].Name := 'Vetores';
Excel.Workbooks[1].Sheets[1].Cells[1,1] := 'VALORES:';
Excel.Workbooks[1].Sheets[1].Cells[1,2] := Datetostr(Now);
52

Excel.Workbooks[1].Sheets[1].Cells[1,3] := Timetostr(Now);
Excel.Workbooks[1].Sheets[1].Cells[3,1] := 'Corrente Fase A';
Excel.Workbooks[1].Sheets[1].Cells[3,2] := 'Corrente Fase B';
Excel.Workbooks[1].Sheets[1].Cells[3,3] := 'Corrente Fase C';
Excel.Workbooks[1].Sheets[1].Cells[3,4] := 'Corrente Neutro';
Excel.Workbooks[1].Sheets[1].Cells[3,5] := 'Tensão Fase A';
Excel.Workbooks[1].Sheets[1].Cells[3,6] := 'Tensão Fase B';
Excel.Workbooks[1].Sheets[1].Cells[3,7] := 'Tensão Fase C';
Excel.Workbooks[1].Sheets[1].Cells[3,8] := 'Horário';
For Linha := 1 to ia do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,1] := mia[Linha];
For Linha := 1 to ib do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,2] := mib[Linha];
For Linha := 1 to ic do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,3] := mic[Linha];
For Linha := 1 to ineutro do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,4] :=
min[Linha];
For Linha := 1 to fa do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,5] := mfa[Linha];
For Linha := 1 to fb do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,6] :=
mfb[Linha];
For Linha := 1 to fc do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,7] := mfc[Linha];
For Linha := 1 to ia do Excel.Workbooks[1].Sheets[1].Cells[Linha+3,8] :=
Timetostr(Now);
Excel.Workbooks[1].SaveAs(concat('c:\Resultados.\Entradas - ',inttostr(cont),'.xls'));
Excel.Workbooks[1].Close;
end;
sbtRelatorio.Enabled := false;
end;

end.

unit Configuracao;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, ExtCtrls, CommInt, ComCtrls;

type
TfrmConfiguracao = class(TForm)
editPar4: TEdit;
editPar2: TEdit;
editPar3: TEdit;
editPar5: TEdit;
editPar6: TEdit;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
53

Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
Label8: TLabel;
editPar1: TEdit;
editPar7: TEdit;
editPar8: TEdit;
editPar9: TEdit;
editPar10: TEdit;
editPar11: TEdit;
editPar12: TEdit;
editPar13: TEdit;
editPar14: TEdit;
editPar15: TEdit;
editPar16: TEdit;
editPar17: TEdit;
editPar18: TEdit;
editPar19: TEdit;
editPar20: TEdit;
editPar21: TEdit;
editPar22: TEdit;
editPar24: TEdit;
editPar23: TEdit;
editPar25: TEdit;
editPar26: TEdit;
editPar27: TEdit;
editPar28: TEdit;
editPar29: TEdit;
editPar30: TEdit;
editPar31: TEdit;
editPar32: TEdit;
editParSenha: TEdit;
Label9: TLabel;
Label10: TLabel;
Label11: TLabel;
Label12: TLabel;
Label13: TLabel;
Label14: TLabel;
Label15: TLabel;
Label16: TLabel;
Label17: TLabel;
Label18: TLabel;
Label19: TLabel;
Label20: TLabel;
Label21: TLabel;
Label22: TLabel;
Label23: TLabel;
54

Label24: TLabel;
Label25: TLabel;
Label26: TLabel;
Label27: TLabel;
Label28: TLabel;
Label29: TLabel;
Label30: TLabel;
Label31: TLabel;
Label32: TLabel;
Label33: TLabel;
Label34: TLabel;
Label35: TLabel;
sbtConfigEnviar: TButton;
sbtConfigSalvar: TButton;
sbtConfigSair: TButton;
Panel1: TPanel;
Panel2: TPanel;
mStatus: TStatusBar;
ProgressBar1: TProgressBar;
procedure sbtConfigSairClick(Sender: TObject);
procedure sbtConfigEnviarClick(Sender: TObject);
procedure sbtConfigSalvarClick(Sender: TObject);
procedure FormCreate(Sender: TObject);

private
{ Private declarations }
public
{ Public declarations }
end;

var
frmConfiguracao: TfrmConfiguracao;

implementation

uses Principal;

{$R *.DFM}

procedure TfrmConfiguracao.sbtConfigSairClick(Sender: TObject);


55

begin
if Application.MessageBox('Tem certeza que deseja sair das configurações?','Confirmação',
MB_IconQuestion + MB_YesNo) = idYes
then
Close;
end;

procedure TfrmConfiguracao.sbtConfigEnviarClick(Sender: TObject);


var
S: string;
Count: Integer;
begin
with TfrmConfiguracao.Create(nil) do
try
ProgressBar1.Max := 96;
Show;
Update;

begin

S := editPar1.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar2.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar3.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar4.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar5.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);
56

S := editPar6.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar7.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar8.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar9.text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar10.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar11.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar12.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar13.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar14.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar15.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
57

ProgressBar1.StepBy(3);

S := editPar16.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar17.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar18.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar19.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar20.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar21.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar22.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar23.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar24.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar25.Text;
58

Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar26.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar27.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar28.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar29.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar30.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar31.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

S := editPar32.Text;
Count := Length(S);
Count := frmPrincipal.Comm1.Write(S[1], Count);
ProgressBar1.StepBy(3);

sbtConfigEnviar.Enabled := false;

end
finally
Free;
end;
end ;
59

procedure TfrmConfiguracao.sbtConfigSalvarClick(Sender: TObject);


var
texto: textfile;

begin
CreateDir('c:\ConfiguracaoReligador.');
If FileExists(concat('c:\ConfiguracaoReligador.\Parametros.txt')) then
begin
assignfile(texto,concat('c:\ConfiguracaoReligador.\Parametros.txt'));
rewrite(texto);
writeln(texto, editPar1.Text);
writeln(texto, editPar2.Text);
writeln(texto, editPar3.Text);
writeln(texto, editPar4.Text);
writeln(texto, editPar5.Text);
writeln(texto, editPar6.Text);
writeln(texto, editPar7.Text);
writeln(texto, editPar8.Text);
writeln(texto, editPar9.Text);
writeln(texto, editPar10.Text);
writeln(texto, editPar11.Text);
writeln(texto, editPar12.Text);
writeln(texto, editPar13.Text);
writeln(texto, editPar14.Text);
writeln(texto, editPar15.Text);
writeln(texto, editPar16.Text);
writeln(texto, editPar17.Text);
writeln(texto, editPar18.Text);
writeln(texto, editPar19.Text);
writeln(texto, editPar20.Text);
writeln(texto, editPar21.Text);
writeln(texto, editPar22.Text);
writeln(texto, editPar23.Text);
writeln(texto, editPar24.Text);
writeln(texto, editPar25.Text);
writeln(texto, editPar26.Text);
writeln(texto, editPar27.Text);
writeln(texto, editPar28.Text);
writeln(texto, editPar29.Text);
writeln(texto, editPar30.Text);
writeln(texto, editPar31.Text);
writeln(texto, editPar32.Text);
writeln(texto, editParSenha.Text);
Closefile(texto);
sbtConfigEnviar.Enabled := true;
60

showmessage ('Dados salvos!')


end
else
begin
assignfile(texto,concat('c:\ConfiguracaoReligador.\Parametros.txt'));
rewrite(texto);
writeln(texto, editPar1.Text);
writeln(texto, editPar2.Text);
writeln(texto, editPar3.Text);
writeln(texto, editPar4.Text);
writeln(texto, editPar5.Text);
writeln(texto, editPar6.Text);
writeln(texto, editPar7.Text);
writeln(texto, editPar8.Text);
writeln(texto, editPar9.Text);
writeln(texto, editPar10.Text);
writeln(texto, editPar11.Text);
writeln(texto, editPar12.Text);
writeln(texto, editPar13.Text);
writeln(texto, editPar14.Text);
writeln(texto, editPar15.Text);
writeln(texto, editPar16.Text);
writeln(texto, editPar17.Text);
writeln(texto, editPar18.Text);
writeln(texto, editPar19.Text);
writeln(texto, editPar20.Text);
writeln(texto, editPar21.Text);
writeln(texto, editPar22.Text);
writeln(texto, editPar23.Text);
writeln(texto, editPar24.Text);
writeln(texto, editPar25.Text);
writeln(texto, editPar26.Text);
writeln(texto, editPar27.Text);
writeln(texto, editPar28.Text);
writeln(texto, editPar29.Text);
writeln(texto, editPar30.Text);
writeln(texto, editPar31.Text);
writeln(texto, editPar32.Text);
writeln(texto, editParSenha.Text);
Closefile(texto);
sbtConfigEnviar.Enabled := true;
showmessage ('Dados salvos!')
end;
end;
61

procedure TfrmConfiguracao.FormCreate(Sender: TObject);


var
texto: textfile;
F: string;
begin
CreateDir('c:\ConfiguracaoReligador.');
If FileExists(concat('c:\ConfiguracaoReligador.\Parametros.txt')) then
begin
assignfile(texto,concat('c:\ConfiguracaoReligador.\Parametros.txt'));
reset(texto);
readln(texto, F);
editPar1.Text :=F;
readln(texto, F);
editPar2.Text :=F;
readln(texto, F);
editPar3.Text :=F;
readln(texto, F);
editPar4.Text :=F;
readln(texto, F);
editPar5.Text :=F;
readln(texto, F);
editPar6.Text :=F;
readln(texto, F);
editPar7.Text :=F;
readln(texto, F);
editPar8.Text :=F;
readln(texto, F);
editPar9.Text :=F;
readln(texto, F);
editPar10.Text :=F;
readln(texto, F);
editPar11.Text :=F;
readln(texto, F);
editPar12.Text :=F;
readln(texto, F);
editPar13.Text :=F;
readln(texto, F);
editPar14.Text :=F;
readln(texto, F);
editPar15.Text :=F;
readln(texto, F);
editPar16.Text :=F;
readln(texto, F);
editPar17.Text :=F;
62

readln(texto, F);
editPar18.Text :=F;
readln(texto, F);
editPar19.Text :=F;
readln(texto, F);
editPar20.Text :=F;
readln(texto, F);
editPar21.Text :=F;
readln(texto, F);
editPar22.Text :=F;
readln(texto, F);
editPar23.Text :=F;
readln(texto, F);
editPar24.Text :=F;
readln(texto, F);
editPar25.Text :=F;
readln(texto, F);
editPar26.Text :=F;
readln(texto, F);
editPar27.Text :=F;
readln(texto, F);
editPar28.Text :=F;
readln(texto, F);
editPar29.Text :=F;
readln(texto, F);
editPar30.Text :=F;
readln(texto, F);
editPar31.Text :=F;
readln(texto, F);
editPar32.Text :=F;
readln(texto, F);
editParSenha.Text :=F;
Closefile(texto);

end
else
begin
showmessage ('Não há parâmetros criados!');
end;
end;

end.

Potrebbero piacerti anche