Upload
vunhi
View
213
Download
0
Embed Size (px)
Citation preview
CENTRO UNIVERSITÁRIO POSITIVO
NÚCLEO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE ENGENHARIA DA COMPUTAÇÃO
MONITOR E GERENCIADOR DE LINHA TELEFÔNICA
CONTROLADO PELO MICROCOMPUTADOR
Monografia do
Projeto Final do curso de
Engenharia da Computação
Aluno: João Candido A. Milasch Filho
Orientador: Prof. Edson Pedro Ferlin
Curitiba
2002
ii
RESUMO
As residências, empresas e locais de acesso a várias pessoas são vulneráveis a utilização
de seus equipamentos e estrutura de forma indevida. Por exemplo, uma pessoa (amigo,
funcionário) pode entrar em um escritório e usar os recursos oferecidos para fins próprios,
como folhas de papel, materiais gerais para escritório, o telefone, entre outros.
Controlar o uso de certos recursos pode ser muito difícil, principalmente quando o
proprietário do local não está sempre presente. A má utilização tem como principal alvo o
telefone, que poderá ser usado sem qualquer tipo de controle, inclusive em ligações
interurbanas.
Pequenos escritórios raramente possuem controle do uso do telefone, já que as soluções
existentes no mercado são muito caras e complexas para este fim. Da mesma forma uma
residência. É difícil observar uma residência que possua algum tipo de central telefônica.
Observando este problema, tão claro e antigo, que surgiu a idéia de um Monitor e Gerenciador
de Linha Telefônica Controlado pelo Microcomputador. Ele não controlará todos os recursos
de um escritório ou de uma residência, mas um recurso que é muito utilizado e muito difícil
de se controlar: o telefone.
Com um microcomputador PC e um Monitor e Gerenciador de Linha Telefônica
Controlado pelo Microcomputador, o controle simples da linha telefônica passa a se tornar
possível, evitando possíveis problemas de custos inesperados.
iii
ABSTRACT
The residences, companies, and places with access to many people are vulnerable to the
undue use of its equipments and resources. For example, a person (friend, employed) can
enter in an office and use the offered resources for his own use, like paper sheet, general
office materials, telephone, etc.
Controlling the use of some resources can be difficult, especially when the owner is not
always on the place, especially with the telephone. The bad utilization has as its principal
target the telephone, which can be used without any control, including interurban calls.
Small offices rarely have something to control the telephone use, since the available
solutions are much expensive and complex. The same way a residence.
It’s hard to see a residence that has a telephone central. Watching this problem, so
obvious and old, that the Telephone Line Manager and Monitor Controlled by the
Microcomputer idea was arrised. It will not control all the resources of an office or a
residence, but a much used and hard to control resource: the telephone.
With a microcomputer PC standard and a Telephone Line Manager and Monitor
Controlled by the Microcomputer, the simple telephone line control comes possible, avoiding
possible problems of unexpected costs.
iv
SUMÁRIO
RESUMO..........................................................................................................................................ii
ABSTRACT .................................................................................................................................... iii
SUMÁRIO .......................................................................................................................................iv
I. LISTA DE FIGURAS ..................................................................................................................vi
II. LISTA DE ABREVIATURAS ................................................................................................. vii
II. LISTA DE ABREVIATURAS ................................................................................................. vii
1. INTRODUÇÃO ........................................................................................................................... 8
2. ESPECIFICAÇÃO .................................................................................................................... 10
2.1. DESCRIÇÃO DO PROJETO ............................................................................................. 10
2.1.1. Módulo Externo ........................................................................................................... 13
2.1.2. Módulo Gerenciador.................................................................................................... 13
2.1.3. Módulo Monitor........................................................................................................... 13
2.2. ESTUDO TEÓRICO .......................................................................................................... 14
2.2.1. Módulo Externo ........................................................................................................... 14
2.2.2. Módulo Gerenciador.................................................................................................... 14
2.2.3. Módulo Monitor........................................................................................................... 15
2.3. ESPECIFICAÇÃO DO HARDWARE............................................................................... 17
2.3.1. Sistema de Processamento ........................................................................................... 17
2.3.2. Decodificador de Discagem......................................................................................... 18
2.3.3. Solicitador de Bloqueio ............................................................................................... 18
2.3.4. Bloqueador de Chamadas ............................................................................................ 19
2.4. ESPECIFICAÇÃO DO SOFTWARE ................................................................................ 19
2.5. ESPECIFICAÇÃO DA VALIDAÇÃO DO PROJETO ..................................................... 22
2.5.1. Módulo Gerenciador.................................................................................................... 22
2.5.1.1. Decodificador de Discagem...................................................................................... 23
2.5.1.2. Bloqueador de Chamada ........................................................................................... 24
2.5.1.3. Solicitador de Bloqueio ............................................................................................ 24
2.5.1.4. Submódulo uC 8051 ................................................................................................. 24
2.5.2. Módulo Monitor........................................................................................................... 26
3. PROJETO .................................................................................................................................. 27
3.1. PROJETO DE HARDWARE............................................................................................. 27
3.1.1. Módulo Gerenciador.................................................................................................... 27
v
3.1.1.1. Memória Externa do Microcontrolador .................................................................... 40
3.1.1.3. Esquemáticos, Componentes e Circuitos.................................................................. 44
3.1.1.3.1. Decodificador DTMF ............................................................................................ 44
3.1.1.3.2. Detector de Estado do Fone ................................................................................... 46
3.2. PROJETO DE SOFTWARE .............................................................................................. 49
3.2.1. Software ....................................................................................................................... 49
3.2.2. Banco de Dados ........................................................................................................... 56
3.2.3. Projeto de Comunicações ............................................................................................ 58
4. CONCLUSÃO ........................................................................................................................... 60
5. REFERÊNCIAS BIBLIOGRÁFICAS ...................................................................................... 62
6. ANEXOS ................................................................................................................................... 63
vi
I. LISTA DE FIGURAS
Figura 1 – Diagrama em Blocos do Sistema _____________________________________________________11 Figura 2 – Diagrama em Blocos do Gerenciador _________________________________________________17 Figura 3 - Diagrama em Blocos do Monitor _____________________________________________________20 Figura 4 - Tabela contendo os dígitos e o sinal binário correspondente_________________________________23 Figura 5 - Fluxograma do Módulo Gerenciador (Geral) ____________________________________________28 Figura 6 - Fluxograma do Processo Inicialização do Módulo Gerenciador _____________________________30 Figura 7 - Fluxograma do processo de Download do Módulo Gerenciador______________________________32 Figura 8 - Fluxograma do Processo Upload do Módulo Gerenciador __________________________________34 Figura 9- Fluxograma do Processo Gerenciamento do Módulo Gerenciador_____________________________36 Figura 10 - Fluxograma do Módulo Bloqueador do Gerenciador _____________________________________38 Figura 11 - Fluxograma do Módulo Decodificador de Discagem do Gerenciador_________________________39 Figura 12 - Fluxograma do Módulo Solicitador de Bloqueio do Gerenciador ____________________________40 Figura 13 - Exemplo de um número telefônico bloqueado armazenado _________________________________41 Figura 14 - Divisão da memória externa________________________________________________________42 Figura 15 - Relógio no Microcontrolador _______________________________________________________44 Figura 16 - Circuito Elétrico com o MT8870_____________________________________________________45 Figura 17 - Circuito Elétrico do Detector de Estado do Fone ________________________________________46 Figura 18 - Tela do Software do Módulo Monitor _________________________________________________50 Figura 19 - Fluxograma Geral do Software do Módulo Monitor ______________________________________51 Figura 20 - Fluxograma do Processo Download do Módulo Monitor __________________________________53 Figura 21 - Fluxograma do Processo Upload do Módulo Monitor_____________________________________54 Figura 22 - Fluxograma do Processo Geração de Relatório _________________________________________55 Figura 23 - Tabelas e Relacionamentos do Banco de Dados _________________________________________57 Figura 24 - Protocolo de Transmissão _________________________________________________________59
vii
II. LISTA DE ABREVIATURAS
bps – Bits por Segundo
PC – Computador Pessoal (Personal Computer).
uC – Microcontrolador
USB – Barramento Serial Universal (Universal Serial Bus)
1. INTRODUÇÃO
Com a evolução da telefonia desde a criação do telefone por Alexander Graham Bell,
em 1876, até os dias de hoje, a sua utilização no mundo inteiro passou a ser em grande escala.
As companhias telefônicas fornecem esta tecnologia para cada usuário, dando a infra-
estrutura e a manutenção devida para manter tudo funcionando devidamente. Isso gera um
custo para tais companhias, e como o objetivo da grande maioria das empresas no mundo todo
é o lucro, um valor além do custo é repassado para o usuário. Ou seja, o usuário que possui
tais serviços irá pagar um valor pelo seu uso. Quando um telefonema é feito, as companhias
cobram um preço pela ligação que basicamente é proporcional à distância e ao tempo que o
usuário utilizou o serviço.
Hoje, existe a necessidade constante de comunicação, que não se restringe ao telefone,
mas também a outros meios de comunicação como a Internet. O telefone é utilizado então
como lazer, para negócios, entre inúmeros motivos.
Porém, embora a telefonia venha evoluindo de forma surpreendente, o seu custo para o
usuário final pode não ser sempre agradável. Uma residência, por exemplo, onde uma família
reside, e onde empregados trabalham, geralmente possui um ou mais contratos com
companhias de telefone, possuindo assim uma ou mais linhas telefônicas. Quando o
proprietário da linha telefônica não está presente no local onde ela está instalada, esta, de
modo geral, fica completamente a disposição de quem quiser utilizá-la. Assim, quando a
companhia de telefone cobrar pelos seus serviços, o seu valor pode surpreender o proprietário.
Existem formas de evitar tal problema. Mas, de modo geral, não são eficazes quanto à
estipulação do custo gerado, e quando eficazes, são de valor muito alto para um usuário
comum.
Desta forma, é interessante algo que seja de baixo custo de aquisição, e simplicidade de
utilização. É isto que este projeto se propõe. De forma resumida, ele irá fazer o controle do
uso de uma linha telefônica impedindo telefonemas que o proprietário ou o administrador do
sistema não deseje que sejam feitos, bem como mostrar a ele, quais telefonemas foram
realizados e os dados referentes a eles (data, duração, custo, etc).
O custo de aquisição deste projeto é baixo por utilizar componentes de baixo custo em
sua composição, e um microcomputador, que está sendo algo tão comum de se encontrar em
residências quanto um aparelho de televisão. É importante ressaltar que um microcomputador
é utilizado para vários fins (processamento de textos, lazer). Este projeto se destina a usuários
que já possuem um microcomputador instalado em sua residência, escritório ou ambiente a ter
sua linha telefônica monitorada e gerenciada, não sendo de nenhuma utilidade para usuários
que não possuem microcomputador.
2. ESPECIFICAÇÃO
De acordo com o fim proposto deste projeto (Monitorar e Gerenciar a utilização de uma
linha telefônica), várias maneiras de implementação poderiam ser levadas em consideração.
Porém, restrições foram adicionadas ao seu escopo. A primeira restrição imposta é
implementar um sistema de simples utilização, visando usuários que não precisem de muitos
conhecimentos na área de informática. A segunda restrição imposta é tornar o sistema de
menor custo possível. Para obedecer tal restrição, o sistema foi projetado e desenvolvido
utilizando os componentes eletrônicos mais vendidos, e de menor custo. A terceira restrição é
projetar o sistema de tal forma que seja mínima a necessidade do usuário realizar
manutenções. Para isso, este foi projetado e desenvolvido visando o menor consumo de
corrente possível.
Este capítulo trata da especificação do projeto do Monitor e Gerenciador de Linha
Telefônica Controlado pelo Microcomputador. Dentro da especificação, todas as limitações e
restrições do sistema serão colocadas e citadas de forma que o projeto fique bem definido
dentro de seu escopo.
2.1. DESCRIÇÃO DO PROJETO
O projeto consiste basicamente de três módulos principais, como pode ser visto na
figura 1.
O primeiro módulo, o Módulo Monitor, é responsável por realizar a interface do usuário
(administrador) com outro módulo, o Módulo Gerenciador, bem como armazenar todos os
dados requeridos pelo sistema. O Módulo Monitor recebe este nome por administrar os dados
e mostrá-los ao usuário de tal forma que o monitoramento to uso da linha telefônica e das
tentativas de telefonemas seja possível.
O segundo módulo, o Módulo Gerenciador, é responsável por administrar os dados
gerados pelo usuário no Módulo Monitor. A partir da administração destes dados, o Módulo
Gerenciador irá realizar o cadastro dos dados referentes aos telefonemas realizados, e
bloquear os telefonemas posteriormente bloqueados pelo usuário no Módulo Monitor. Por
realizar o gerenciamento da linha telefônica, o módulo recebe o nome de Gerenciador.
O terceiro e último módulo, o Módulo Externo é constituído de elementos que não são
parte do projeto, mas são necessários para o seu funcionamento. Ou seja, tal módulo é
constituído de elementos cuja implementação não é necessária, mas sim o estudo dos seus
comportamentos e das suas funcionalidades.
Figura 1 – Diagrama em Blocos do Sistema
O Módulo Gerenciador consiste em um hardware microprocessado com memória
auxiliar (externa). A memória do Microcontrolador, que faz o processamento dentro do
Gerenciador, é basicamente dividida em duas regiões principais. A primeira região armazena
todos os telefonemas, ou tentativa de telefonemas realizadas. A outra região é uma lista de
números telefônicos bloqueados. Enquanto o sistema estiver ligado, se o usuário tentar fazer
um telefonema para um número de telefone que estiver armazenado na lista de bloqueados, o
Microcontrolador enviará um sinal para o bloqueador pela própria linha telefônica
requisitando o bloqueio da chamada. As informações de todos os telefonemas realizados ou
dos telefonemas bloqueados pelo sistema são então armazenadas na região de chamadas
realizadas.
Um aspecto importante do gerenciador é o fato do Módulo Gerenciador funcionar sem a
necessidade do computador estar ligado, ou seja, ele trabalha de forma off-line. Quando o
administrador desejar, ele, através do Módulo Monitor, irá requerer a transferência, assim as
informações armazenadas dentro do Módulo Gerenciador serão enviadas para o Módulo
Monitor, onde tais informações serão tratadas e mostradas.
O gerenciador será alimentado com uma bateria de 9V comum, o que é possível por ser
projetado com componentes de baixo consumo. Sem tal alimentação, em problemas como
queda de luz, os usuários estariam livres para usufruir o telefone sem o administrador saber.
O Módulo Monitor consiste basicamente em um software escrito para ser executado em
um computador PC comum, sendo esse responsável pela interface do usuário com o Módulo
Gerenciador, bem como pela interface com o Banco de Dados (outro módulo do Módulo
Monitor). Tal software foi desenvolvido para a plataforma Windows todas as versões 32 bits.
Dentro do Módulo Monitor, além do software, outro módulo está contido, o Módulo de
Banco de Dados. O Banco de Dados foi projetado para armazenar todas as informações
necessárias para o funcionamento do sistema. Como por exemplo:
• Ligações feitas, data e hora, duração, usuário que provavelmente fez a ligação.
• Números telefônicos bloqueados.
• Usuários do telefone onde o sistema estará funcionando.
Através destas informações, o software gera relatórios, mostrando todas as informações
organizadas para o administrador. Com os relatórios, ele tomará decisões cabíveis. Por
exemplo, se o número 222-9999 aparece no relatório freqüentemente usado e de custo maior,
então o administrador poderá verificar quem geralmente liga para este número e poderá ou
não bloquear este número de telefone.
Os relatórios também fornecem estimativas de gastos totais e por ligação. Para isto, o
software possibilita a configuração do custo das ligações locais, interurbanas, etc. Assim,
tendo a duração de cada uma dos telefonemas realizados, o software executa um cálculo,
multiplicando o tempo pelo custo e dando uma estimativa de quanto que foi gasto.
Se o administrador desejar bloquear um número de telefone, este passará a ser indicado
como bloqueado no Banco de Dados. Assim, quando o administrador terminar todas as
configurações, a nova configuração deverá ser enviada ao Gerenciador. Estas informações
serão enviadas para o Gerenciador através da porta serial. Dentro do Gerenciador as
informações serão organizadas corretamente em sua memória. Por esta mesma porta que as
informações irão trafegar do Gerenciador para o Monitor, quando o administrador desejar ver
as novas informações coletadas (quais telefonemas foram feitos, e seus dados).
Tópicos em seguida irão dar uma breve explicação sobre os módulos, porém no decorrer
do trabalho informações mais aprofundadas serão dadas sobre eles.
2.1.1. Módulo Externo
O Módulo Externo recebe este nome por possuir itens externos ao sistema, porém
necessários para o seu funcionamento. Os itens que compõe este módulo não precisaram ser
implementados, mas sim estudados de forma a garantir o funcionamento correto do sistema.
O sistema foi projetado apenas para atender um tipo de discagem: o de tom. Como
discagens por tom são utilizados em larga escala, e discagens por pulso estão sendo se
tornando obsoletas, o sistema de discagens por tom foi escolhido.
2.1.2. Módulo Gerenciador
O Módulo Gerenciador foi completamente implementado, tanto em hardware quanto em
software. Ele é microprocessado com o microcontrolador 8051, e responsável por gerenciar a
linha telefônica de acordo com as informações que o administrador lhe passa. O Módulo
Gerenciador, como ser observado na figura 1, está ligado diretamente ao Módulo Externo pela
Linha Telefônica Interna do local.
2.1.3. Módulo Monitor
O Módulo Monitor é a interface entre o administrador e o gerenciador. Através dele o
administrador poderá realizar ações como bloquear ou desbloquear e desbloquear os números
telefônicos. Este módulo foi quase todo implementado, exceto o computador que é um
microcomputador padrão PC (Personal Computer).
2.2. ESTUDO TEÓRICO
Na implementação de todos os módulos, estudos mais aprofundados quanto à
funcionalidade e implementação foram necessários. Entretanto, várias decisões foram
tomadas quanto ao projeto e implementação deles, em termos de hardware e software.
2.2.1. Módulo Externo
Como nenhum item deste módulo foi implementado, somente o estudo da
funcionalidade destes foi necessária. Porém, baseado em informações deste módulo que
decisões quanto à implementação do Módulo Gerenciador foram tomadas.
2.2.2. Módulo Gerenciador
O Módulo Gerenciador usa o microcontrolador 8051 como elemento principal, pois é
um dispositivo facilmente programável e possui características (como capacidade, velocidade
e tamanho físico) que se enquadram nas necessidades deste módulo.
Um problema para o módulo gerenciador é como saber quais teclas o usuário do
telefone pressionou. Por isso um decodificador de discagem deve ser utilizado. O
decodificador de discagem interpreta a tecla pressionada por quem está usando o telefone e
envia um sinal digital para o processador, onde tal sinal é tratado.
No Brasil utilizam-se dois sistemas de discagem distintos: tom e pulso. A discagem por
tom funciona, de forma simplificada, da seguinte maneira: ao pressionar uma tecla, o telefone
gera um sinal modulado em uma duas freqüências adotadas como padrão. Ao pressionar outra
tecla, outro sinal, equivalente à tecla, como descrito em [ALI – 2000].
A discagem por pulso é feita com um conjunto de pulsos em um determinado tempo.
Cada pulso é uma variação de tensão na linha telefônica, em um determinado tempo
padronizado. Um trem de pulsos pode ser gerado colocando e retirando o fone do gancho,
desde que o tempo entre estas duas ações esteja obedecendo aos padrões. Quando o aparelho
telefônico está com o fone fora do gancho, a tensão é baixa (variando aproximadamente de
7V à 12V). Quando o fone está no gancho, a tensão é alta (aproximadamente 50V). Um pulso
do conjunto de pulsos tem sua tensão variando nestes dois pontos, de forma retangular. Se o
usuário pressionar a tecla “1” por exemplo, o telefone irá gerar um pulso (uma onda quadrada
variando de 7V para 50V e para 7V novamente, em um tempo definido). Se o usuário
pressionar a tecla “0”, o telefone irá gerar dez pulsos em um intervalo de tempo.
No projeto da decodificação de discagem, a existência de componentes prontos no
mercado que fazem a decodificação corretamente foi verificada. Componentes foram
encontrados, e estão sendo mostrados e descritos no capítulo Projeto.
Outro item muito importante deste módulo é o bloqueador de chamadas. O bloqueador
de chamadas é responsável por bloquear os telefonemas cujo número está bloqueado a
comando do módulo principal. Se o usuário discar um número telefônico bloqueado, o
sistema enviará um sinal para o bloqueador, que fará interrupção da chamada.
O bloqueador deve ser instalado na entrada da linha telefônica no local onde o sistema
for instalado, antes de qualquer ponto de telefone. O pedido de bloqueio é enviado pelo
sistema e chegará ao bloqueador pela própria linha telefônica.
O sinal que faz a requisição de bloqueio do telefonema é uma queda de tensão na linha
telefônica. Como comentado anteriormente, quando o fone do aparelho telefônico está fora do
gancho a tensão é de aproximadamente 10V. Esta tensão dificilmente é menor de 7V. Por este
motivo, a tensão escolhida para realizar o requerimento de bloqueio, é de 5V. Desta forma,
quando o sistema identificar um telefonema com número bloqueado, um relé será acionado
para gerar uma carga em paralelo ao aparelho telefônico, derrubando assim a tensão para o
nível desejado. Este item será explicado posteriormente.
2.2.3. Módulo Monitor
Decisões quanto à implementação dos módulos deste módulo também foram
necessárias. Para a implementação do software, a linguagem escolhida foi C++ juntamente
com o compilador Borland C++ Builder 6.0 que tem um grande potencial e alta produtividade
por apresentar resultados rápidos e fáceis.
Como o banco de dados não é muito complexo, não foi necessário um Sistema
Gerenciador de Banco de Dados de grande potencial. Por este motivo um banco de dados
simples foi implementado no Microsoft Access.
A comunicação do Módulo Monitor com o Módulo Gerenciador deve ser feita por uma
porta de comunicação serial do computador. Tal porta de comunicação foi escolhida por
possuir taxa de transmissão aceitável para um conjunto pequeno além do microcontrolador
8051 também possuir uma porta de comunicação serial no mesmo padrão (RS232).
2.3. ESPECIFICAÇÃO DO HARDWARE
O hardware implementado está limitado ao Módulo Gerenciador e os itens descritos a
seguir serão os submódulos dele.
Figura 2 – Diagrama em Blocos do Gerenciador
2.3.1. Sistema de Processamento
O microcontrolador (uC) 8051 é o elemento principal do módulo gerenciador. Quando
em funcionamento, ele executa um software programado na linguagem Assembly para 8051
que realiza o controle do Módulo Gerenciador.
Quando o usuário retirar o fone do aparelho telefônico do gancho e teclar o primeiro
dígito de seu telefonema, o Decodificador de Discagem detecta a ação e gera uma interrupção
no microcontrolador, colocando o sinal binário equivalente em suas saídas. Após esta
interrupção, o microcontrolador importa o dado identificado pelo decodificador por uma de
suas portas, e armazena em sua memória. Armazenado o número, este é procurado na região
de Bloqueados. Caso não seja encontrado, o microcontrolador espera por um próximo dígito
ou pelo usuário colocar o fone no gancho novamente. Porém, se o usuário discou para algum
número que consta na memória de bloqueados, um sinal de um bit é gerado, ativando o relé,
que fará com que a tensão na linha telefônica caia para 5V. O Bloqueador identificará esta
queda, e bloqueará o telefonema.
Se o administrador desejar as informações armazenadas pelo Módulo Gerenciador, uma
mensagem de requisição é enviada do computador para o microcontrolador. Quando o
Módulo Gerenciador receber a mensagem de requisição, o microcontrolador, através da porta
serial, envia todas as informações armazenadas dos telefonemas.
Como a alimentação do microcontrolador é de uma bateria de 9V comum, o consumo de
potência não pode ser muito alto, pois com um consumo alto, a duração da bateria é muito
pequena.
2.3.2. Decodificador de Discagem
O Decodificador de Discagem é responsável pela identificação de qual tecla do aparelho
telefônico está sendo pressionada pelo usuário. Isto é feito através da interpretação dos sinais
modulados em freqüência existentes na linha telefônica.
O Decodificador de Discagem também é responsável pela identificação de quando o
fone foi retirado do gancho, e de quando o fone foi colocado no gancho novamente. Sabe-se
que quando o fone é retirado do gancho, o aparelho telefônico utilizado passa a ser o loop
entre a central telefônica e a linha telefônica interna. A linha telefônica, então, passará a ter
corrente elétrica circulando pelo loop. Como a corrente elétrica fornecida é muito limitada,
existindo uma carga na linha telefônica, a tensão cai para próximo de 10V. Isto pode ser
interpretado pelo Decodificador de Discagem através da implementação de um circuito que
detecte o nível de tensão. Neste projeto, o detector foi configurado para 24V, sendo que
abaixo de 24V é considerado que o fone está fora do gancho do aparelho telefônico, e acima
deste nível, é considerado o contrário.
O Decodificador de Discagem possui então uma entrada (que será apenas uma extensão
da linha telefônica) que está conectada à linha telefônica, uma saída de apenas um bit
conectada diretamente ao microcontrolador no pino de interrupção externa, e outra saída de 4
bits, conectada à porta do microcontrolador.
2.3.3. Solicitador de Bloqueio
O Solicitador de Bloqueio consiste em um pequeno hardware que ao ser acionado,
diminui a tensão presente na linha telefônica para 5V. O Solicitador de Bloqueio está ligado
diretamente ao microcontrolador por um bit de sua porta.
O Solicitador de Bloqueio possui uma entrada de 1 bit conectado diretamente ao
microcontrolador, e uma saída conectada aos pólos positivo e negativo da linha telefônica.
2.3.4. Bloqueador de Chamadas
O Bloqueador de Chamadas é um pequeno hardware ligado diretamente à linha
telefônica. Para o funcionamento correto do sistema, ele deverá ser instalado entre a linha
telefônica externa e a linha telefônica interna do local, ou seja, logo na entrada dos fios de
cobre no ambiente.
Quando o Bloqueador receber a ordem de bloqueio, ele abre o loop feito por algum
aparelho telefônico, cortando a ligação. Desta forma, se faz necessário um circuito detector de
nível ajustado para 5V, que é ativado quando o nível está inferior a esta tensão. Ao ser
ativado, um relé que está configurado em “Normalmente fechado” é polarizado, abrindo o
loop por um período de cerca de 1 segundo, o mínimo necessário para a central telefônica
pública identificar como o evento “fone colocado no gancho”. Desta forma, o bloqueador
apenas engana a central telefônica.
2.4. ESPECIFICAÇÃO DO SOFTWARE
O software do sistema é basicamente o Módulo Monitor, da mesma forma que o
hardware é basicamente o Módulo Gerenciador (apesar de também existir um software
embarcado no microcontrolador). A figura 3 mostra o Diagrama em Blocos do Monitor.
Figura 3 - Diagrama em Blocos do Monitor
O software foi desenvolvido na linguagem C++ e utilizando o compilador Borland C++
Builder 6.0, para a plataforma Windows em todas as versões 32bits. Agregado ao software, o
banco de dados foi implementado com a ferramenta Microsoft Access.
O software apresenta uma interface amigável e simples com o usuário, como quase
todos os softwares implementados para Windows. Ele é simples, prático, porém atende a
todas as requisições do administrador.
As principais funções do software são:
• Gerar relatórios: Os relatórios mostram todas as informações em forma de tabela,
onde o administrador poderá ordenar seus dados da forma que quiser. As
informações mostradas neste relatório são, basicamente, os telefonemas
realizados e bloqueados.
• Fazer download de dados do gerenciador: Quando o administrador desejar ver
quais ligações foram feitas, quanto já foi gasto, ele deverá selecionar uma opção
existente no software, e os dados serão atualizados no banco de dados.
• Bloquear números telefônicos: Caso o administrador ache necessário fazer o
bloqueio de algum número telefônico, ele deverá selecionar a opção relativa e,
ao confirmar, o dado será enviado para o Módulo Gerenciador.
• Cadastro em Banco de Dados: Várias informações devem ser cadastradas no
banco de dados, para o funcionamento correto do sistema. Estas informações
incluem números telefônicos, para poder selecionar o número como bloqueado
ou não, DDDs e Operadoras, para fins de cálculo do custo da ligação bem como
bloquear as ligações interurbanas, Usuários, para poder relacionar um número
telefônico a um usuário que freqüentemente liga para tal número e Tarifas, para
poder configurar o valor correto das tarifas.
Nota-se que por ser um software simples, não há necessidade de velocidade de
processamento muito alta, mas deve ser rápido o suficiente para processar as informações
trafegadas entre o Módulo Monitor e o Módulo Gerenciador. Como a taxa de transmissão do
microcontrolador do Módulo Gerenciador não é muito alta (neste projeto está sendo utilizada
a taxa de transmissão de 19200 bps), não é necessária uma velocidade de processamento
muito grande.
O software necessita de um microcomputador PC para ser executado, com o sistema
operacional Windows em qualquer de suas versões 32 bits (Windows 95, Windows 98,
Windows NT, Windows 2000, Windows ME, Windows XP) instalado.
O microcomputador deve possuir ao menos uma porta serial padrão RS232 disponível
para que a comunicação entre os módulos possa ser realizada.
2.5. ESPECIFICAÇÃO DA VALIDAÇÃO DO PROJETO
Os testes de validação do sistema serão realizados para verificações de funcionamento
do projeto. Para tal, todos os módulos devem ser testados independente, e por fim, de forma
geral.
Os seguintes tópicos mostrarão os testes a serem realizados com cada um dos módulos
do sistema.
2.5.1. Módulo Gerenciador
No módulo gerenciador, os seguintes testes devem ser realizados para sua validação:
1. Números telefônicos devem ser cadastrados e indicados como bloqueados no software
do módulo monitor.
2. Os números telefônicos bloqueados devem ser enviados ao módulo gerenciador. Caso
seja necessário testar este módulo de forma completamente independente, basta utilizar
um software que possibilite o envio de dados pela porta serial. Para tanto, basta
conhecer o protocolo, e enviar os dados para o microcontrolador de forma a bloquear
números telefônicos.
3. Várias tentativas de telefonemas devem ser realizadas, incluindo números telefônicos
bloqueados e não bloqueados. O sistema deverá bloquear os telefonemas bloqueados, e
deixar que os telefonemas não bloqueados sejam completados até o usuário coloque o
fone no gancho.
4. Depois de realizados os testes no item 3, através do software do Módulo Monitor, ou
ainda através do software utilizado para enviar os números telefônicos bloqueados, deve
ser feito o requerimento de download das informações cadastradas pelo Módulo
Gerenciador, e após a conclusão, os dados devem ser conferidos com os dados das
chamadas completadas e com os dados das chamadas bloqueadas.
Caso seja necessário, os subtópicos seguintes informarão como proceder nos testes
individuais dos submódulos do Módulo Gerenciador.
2.5.1.1. Decodificador de Discagem
O Decodificador de Discagem tem sua entrada ligada diretamente à linha telefônica. As
teclas do telefone, que deve estar em paralelo ao decodificador, ou seja, ligado a uma outra
extensão da linha telefônica, devem ser pressionadas, e o valor de saída deve ser anotado e
comparado com o valor que deveria ser correto, seguindo os valores contidos na figura 4.
Figura 4 - Tabela contendo os dígitos e o sinal binário correspondente
Nos testes da funcionalidade total do Decodificador, teclas do aparelho telefônico
devem ser pressionadas por um tempo determinado, grande, curto, variando a freqüência de
pressionamento, para alta e baixa, pressionando teclas aleatórias e a mesma tecla
repetidamente.
Não importando o tempo de pressionamento de uma tecla do telefone, o decodificador
deve mostrar apenas um valor no tempo devido.
2.5.1.2. Bloqueador de Chamada
Nos testes deste submódulo, deve-se colocar em paralelo à linha telefônica, um
potenciômetro de 10KO, mas após o bloqueador. Iniciando a resistência do potenciômetro em
10KO, esta deve ser diminuída de tal forma que a tensão na linha telefônica caia para
aproximadamente 5V. Nesta tensão, a linha será bloqueada, podendo ser observado medindo a
tensão na parte anterior ao bloqueador, que deverá ser de aproximadamente 48V, e na parte
posterior ao bloqueador, que deverá ser de 0V, já que nenhuma corrente deve circular e
nenhuma tensão deve existir.
O mesmo deve ser repetido com um telefone em paralelo ao potenciômetro com o seu
fone fora do gancho.
2.5.1.3. Solicitador de Bloqueio
Nos testes deste submódulo, um telefone deve estar conectado na linha telefônica, e
estar fora do gancho. Da mesma forma, o bloqueador deve estar desligado para que não seja
aberto o loop. O Solicitador de Bloqueio deve ser então ativado, fornecendo-se 5V em sua
entrada, um número determinado de vezes, a critério de quem estiver testando. Em todas as
ativações, a tensão da linha telefônica, medida em qualquer lugar deve ser de 5V no período
de ativação (enquanto houver 5V em sua entrada).
2.5.1.4. Submódulo uC 8051
O software deste submódulo deve ser executado, onde todas as interrupções devem ser
geradas e devem ser atendidas corretamente. Todos os tipos de entrada devem ser colocados
no 8051 a fim de verificar se ele falha, se o software entra em laço infinito, trava ou erra.
O software não pode travar, funcionando sempre, e por um longo período de tempo.
2.5.2. Módulo Monitor
Na validação deste módulo, todas as funções do software devem ser executadas,
verificando se a saída está de acordo com o desejado, não podendo nunca dar erros funcionais
como invasão de memória, entrar em laço infinito, travar, realizar operações inválidas no
banco de dados. O software deve gerar os relatórios corretamente, deve ser tolerante a erros,
onde dados errôneos devem ser gerados e colocados em sua entrada para a verificação de sua
saída.
Para testar a transmissão, devem ser feitos requerimentos de Download e
Upload.Quando a transmissão estiver sendo feita, deve-se retirar o cabo serial da porta para
verificar se o software entra em algum laço infinito, ou se acusa erro de timeout. As
transmissões devem ser realizadas inúmeras vezes, tanto de envio, quanto de recepção.
3. PROJETO
O projeto detalhado neste capítulo foi feito de acordo com as especificações colocadas
no capítulo anterior. A especificação, fase anterior a esta, foi responsável pela definição do
escopo do sistema, identificando como e em que direção ele funciona.
Nesta fase, tudo que acontecerá no sistema (eventos, interrupções) deverá ser detalhado
e projetado. Como o sistema está dividido basicamente em hardware e software, os projetos
destes serão apresentados desta maneira. O projeto do software embarcado no
microcontrolador será apresentado como um todo no Módulo Gerenciador, já que este, apesar
de ser um software está sendo incorporado em um item de hardware que foi projetado.
Seguindo a ordem da especificação, o projeto de hardware será apresentado, seguido do
projeto de software.
3.1. PROJETO DE HARDWARE
Para a implementação do hardware do sistema, foram projetados fluxogramas e
esquemáticos. Os fluxogramas descrevem o funcionamento do hardware, mediante chegada
de eventos, ou seja, entradas no sistema. Entretanto, as saídas também são descritas, bem
como o funcionamento do sistema. Os esquemáticos descrevem o como o hardware será
implementado, de forma detalhada, bem como quais componentes serão utilizados.
Como comentado anteriormente, inicialmente serão apresentados os fluxogramas de
hardware, onde o módulo gerenciador se enquadra.
3.1.1. Módulo Gerenciador
O módulo gerenciador apresenta uma importância completa no sistema, sendo o
elemento principal deste. Ele é responsável pelo controle efetivo da linha telefônica, onde
efetivamente bloqueia as chamadas as quais o administrador não deseje que sejam feitas.
Os fluxogramas deste módulo serão apresentados no decorrer deste tópico, com sua
devida explicação anexada a eles.
Na figura 5, é apresentada uma visão geral do funcionamento do módulo gerenciador. O
fluxograma contido nesta figura mostra não somente o funcionamento do software contido no
módulo, mas também a seqüência de eventos e processos que este manipula. Os blocos dos
fluxogramas mostrados são explicados através de suas numerações.
Figura 5 - Fluxograma do Módulo Gerenciador (Geral)
A seguir, estão listados os passos do fluxograma.
1) Início do fluxograma.
2) Este processo se torna responsável pela inicialização das variáveis, bem como da configuração
dos registradores do microcontrolador (configurações de interrupções, timers, etc). Todo este
processo é feito por software, sendo este contido no microcontrolador.
3) O requerimento de download é feito pelo PC através do software contido nele e enviado ao
microcontrolador. Este requerimento tem por fim pedir ao microcontrolador para enviar todas as
chamadas cadastradas por ele.
4) O requerimento de upload também é feito pelo PC através do software contido nele. Este
requerimento tem por fim informar ao microcontrolador que o usuário deseja atualizar a lista de
telefones bloqueados, enviando novamente todos os telefones.
5) Este bloco se referencia a um evento gerado pelo aparelho telefônico quando o usuário pressiona
a primeira tecla. Tal evento é identificado pelo Decodificador de Discagem, e uma interrupção
externa é gerada no microcontrolador.
6) O processo gerenciamento cuida de bloquear e armazenar as chamadas telefônicas realizadas.
Este processo possui um fluxograma específico que mostra o funcionamento dele.
7) Quando o microcontrolador recebe um requerimento de download, este processo é executado. Da
mesma forma que o processo 6, ele possui um fluxograma específico que mostra o
funcionamento dele.
8) Quando o microcontrolador recebe um requerimento de upload, este processo é executado. Da
mesma forma que o processo 6 e 7, um fluxograma especifico para este processo foi feito.
Pôde-se observar que o fluxograma do funcionamento geral do módulo gerenciador foi
dividido em fluxogramas menores. Isto foi necessário já que o fluxograma apresentado ficaria
muito grande, e tornaria difícil organizá-lo no projeto.
A figura 6 possui o fluxograma do processo de Inicialização, que será executado assim
que o sistema for ligado, ou no reset do microcontrolador.
Figura 6 - Fluxograma do Processo Inicialização do Módulo Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 6.
1) Início do fluxograma.
2) Os dados serão enviados e transmitidos do microcontrolador pela sua porta serial. Portanto, esta
deverá ser configurada. As configurações adotadas foram: Porta serial configurada no modo de
operação 1, onde a transmissão é assíncrona e de 8 bits de dados e 2 de controle, sendo um o
start bit e outro o stop bit [DNI – 2000]. A taxa de transmissão será configurada para 19200 bits
por segundo.
3) As interrupções externas tornam-se necessárias, pois o microcontrolador deve estar preparado
para tratar de algumas rotinas como tirar o fone do gancho e colocá-lo novamente no gancho. As
interrupções internas são todas as interrupções utilizadas indiretamente. Por exemplo, os
temporizadores que serão utilizados para a transmissão serial, como também para o relógio do
sistema, utilizam interrupções internas.
4) Os temporizadores utilizados deverão ser configurados corretamente de acordo com o necessário
para a transmissão serial, bem como para o relógio do sistema que será implementado para poder
fornecer a data e hora atual.
5) As variáveis de controle interno do programa como flags, variáveis de backup (que armazenam
valores de ponteiros, etc) são inicializadas com seus respectivos valores.
6) Fim do fluxograma.
A figura 7 possui o fluxograma do processo de download (processo responsável por
enviar todos os dados dos telefonemas cadastrados pelo Módulo Gerenciador para o Módulo
Monitor).
Figura 7 - Fluxograma do processo de Download do Módulo Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 7.
1) Início do fluxograma.
2) O ponteiro para memória externa do microcontrolador (DPTR) é inicialmente inicializado com o
valor da região de telefonemas cadastrados. Esta região inicia na posição 15E0h (hexadecimal).
3) Se logo no início da chamada que está para ser enviada for encontrado o valor 61h (responsável
por indicar o fim da região de memória, tanto para a região de números bloqueados, quanto para
a região de telefonemas cadastrados), indica que a região de memória acabou. Tal valor é o
mesmo usado pelo protocolo para indicar que a transmissão acabou. Desta forma, o byte é
enviado, indicando Fim de Transmissão. Observação: Quando nenhuma chamada foi cadastrada,
o único valor que é enviado é o próprio Fim de Transmissão. O Módulo Monitor irá interpretar
este valor, que mostra que nenhuma chamada foi cadastrada.
4) Os 4 primeiros bytes de cada chamada indicam o tempo em que o telefonema se iniciou. Tal
tempo é registro do tempo do relógio interno do microcontrolador, de segundos apenas,
possuindo 4 bytes. Este relógio está explicado de melhor forma no subtópico Relógio do
MicroControlador.
5) Agora, um loop é iniciado até terminar de enviar o número do telefonema.
6) Este é o critério de parada, passando para o bloco 7 quando obedecer tal critério.
7) Quando o byte não for mais um número, indicando ‘b’ (telefonema bloqueado) ou ‘c’
(telefonema completado), o programa deve considerar como o fim do número do telefonema
atual. Desta forma, os próximos 4 bytes irão indicar o tempo em que o telefonema acabou. O
byte seguinte aos 4 bytes do tempo final sempre indicará F0h. Por isso ele também é enviado,
sem teste algum.
8) Este bloco é apenas ilustrativo, onde nada é executado, mas somente mostra que o próximo
número telefônico, ou o Fim de Transmissão será enviado.
9) Quando o byte 61h for encontrado, e quando este não for pertencente ao tempo inicial ou final,
não terá mais nenhum número para enviar. Como 61h também é o byte que representa o Fim de
Transmis são, ele será enviado, indicando o fim da transmissão.
10) Fim do fluxograma.
A figura 8 mostra o fluxograma do processo de Upload. Este processo é encarregado de
receber dados do PC. Tais dados são os números telefônicos bloqueados que o administrador
do sistema bloqueou.
Figura 8 - Fluxograma do Processo Upload do Módulo Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 8.
1) Início do fluxograma.
2) Este bloco de decisão é executado automaticamente pelo microcontrolador. O start bit é o
primeiro bit recebido pelo microcontrolador em uma transmissão. Ele é necessário quando a
transmissão serial é assíncrona. Quando o microcontrolador recebe o start bit, uma interrupção da
serial é gerada pelo sistema, e a rotina de recepção pode ser executada.
3) Quando o start bit é recebido, uma rotina será executada a fim de armazenar o byte que foi
recebido em seguida, seqüencialmente, em uma região temporária de memória. Isto será feito até
que um byte separador for recebido. Este byte separador separará os números telefônicos.
4) Os dados são válidos quando o número telefônico bloqueado for inteiramente recebido. Este
bloco será responsável por realizar este teste.
5) Caso os dados recebidos não indicarem um número telefônico bloqueado, o dado recebido
poderá indicar um fim de transmissão. Isto será testado, e caso seja um fim de transmissão, a
rotina de recepção terminará. Caso não seja, o dado será um número telefônico incompleto, que
ainda está sendo recebido, portando, um novo start bit será esperado.
6) Caso o teste do bloco 4 for positivo, ele deverá ser transferido para a memória onde os telefones
bloqueados serão armazenados.
7) Fim do fluxograma.
Os dados recebidos sobrescreverão os dados antigos, ou seja, todos os números
telefônicos serão enviados, não importando se o telefone já estava na lista de bloqueados ou
não.
O fluxograma contido na figura 9 se referencia ao processo de Gerenciamento. Este
processo é encarregado de bloquear a chamada telefônica ou de mantê-la em curso,
armazenando os dados referentes a ela.
Figura 9- Fluxograma do Processo Gerenciamento do Módulo Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 9.
1) Início do fluxograma.
2) Se este é o primeiro número do telefonema a ser armazenado na memória, o valor do ponteiro
para a memória externa será exatamente o valor do início da região de telefonemas cadastrados
(15E0h). Caso não seja, o valor será diferente, mas em posições de memória posteriores. Desta
forma, sempre que um número de telefonema é cadastrado na memória, ele o valor do ponteiro
para a memória externa deve ser salvo. Por isso, neste processo, tal valor salvo anteriormente
salvo é carregado, assegurando o armazenamento em posição correta da memó ria, sem
problemas de perda de dados.
3) O tempo inicial é armazenado, que indicará quando a ligação começou. Isto é feito por colocar o
tempo atual contido no relógio nas posições de memória corretas.
4) O valor do dígito pressionado pelo usuário do telefone é armazenado. Este valor é transformado
em caractere ASCII. Por exemplo, o usuário digitou a tecla ‘1’ do telefone. O valor de 4
mostrado pelo decodificador DTMF é 0001b (base binária). O caractere 1 em ASCII é o valor
01h somado de 30h, tornando-se 31h. Isto é feito para simplificar na visualização dos valores e
para na transmissão e recepção destes dados, o software não ter que executar nenhum tratamento
especial.
5) Quando o número é armazenado, este deve ser verificado se está na região de bloqueados ou não.
Não somente o último número digitado é verificado, mas sim o conjunto de todos os números
que foram pressionados desde a retirada do fone do aparelho telefônico do gancho.
6) Se ele foi encontrado na região de bloqueados, o programa executa uma rotina para efetuar o
bloqueio. Se não, o programa passa a esperar o próximo evento (pressionar de tecla ou colocar
fone no gancho).
7) Este processo é executado quando o teste do bloco 6 for positivo. Quando o telefonema for
bloqueado, na região de chamadas, este precederá do valor ‘b’ (62h).
8) O tempo final é armazenado, da mesma forma que o armazenamento no bloco 3.
9) F0h também é armazenado, identificando na memória que o armazenamento do telefonema
terminou. E como o telefone armazenado é feito após o último que estava armazenado
posteriormente, o byte 61h é armazenado, indicando o fim da região de chamadas.
10) O valor do ponteiro de memória externa é salvo, para quando o próximo telefonema for
armazenado o bloco 2 deste fluxograma recupere este valor salvo e armazene na posição correta.
11) Caso o teste do bloco 6 não seja verdadeiro, o programa pára aguardando o próximo evento
(colocar fone no gancho ou pressionar nova tecla). Este bloco testa se o próximo número foi
digitado e, caso sim, o bloco 4 passa a ser executado.
12) Este bloco testa se o fone foi colocado no gancho, e caso sim, o bloco 13 passa a ser executado.
13) Como o telefonema não foi bloqueado, da mesma forma que no bloco 7, um caractere passa a
indicar o status do telefonema. Neste caso, como não foi bloqueado, o caractere ‘c’ (63h) é
armazenado.
14) O tempo final então é armazenado.
15) E o ponteiro da memória externa é salvo.
16) Fim do fluxograma.
Nota-se claramente que este é o processo mais complexo, pois ele é o responsável por
quase tudo que o sistema faz. Ele cuida da parte principal do sistema, que é cadastrar as
chamadas realizadas bem como bloquear as chamadas não desejadas.
Para assegurar o bom funcionamento do projeto, este processo teve de ser bem
implementado, seguindo este fluxograma para o seu funcionamento.
A figura 10 mostra o fluxograma do módulo Bloqueador. Este módulo é um módulo
simples, porém importante no sistema.
Figura 10 - Fluxograma do Módulo Bloqueador do Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 10. 1) Início do fluxograma.
2) Caso a tensão da linha tenha caído para aproximadamente 5V, o bloqueador irá identificar tal queda,
acionando o relé que irá abrir, bloqueando a chamada.
3) Este bloco descreve a abertura do loop entre o telefone e a central telefônica.
O Sub-Módulo Decodificador de Discagem tem o seu funcionamento descrito no
fluxograma contido na figura 11. Este submódulo não possui somente o decodificador DTMF,
mas também um detector de nível que detecta os eventos como colocar o fone no gancho.
Figura 11 - Fluxograma do Módulo Decodificador de Discagem do Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 11. 1) Início do fluxograma.
2) O Decodificador DTMF é o responsável por este bloco. Quando um tom DTMF é detectado na
linha telefônica, o Decodificador DTMF converte o tom para binário, e no fim da conversão, um
sinal de um de seus pinos é jogado para 5V enquanto ele estiver detectando (no caso do usuário
estar segurando o botão do telefone).
3) Caso não tenha recebido sinal algum, detector de nível testará a tensão na linha telefônica. Caso a
tensão esteja abaixo do nível de 24V, o fone está fora do gancho. Caso contrário, ele está no
gancho.
4) Caso o fone tenha sido tirado do gancho, uma interrupção externa será gerada no
microcontrolador, avisando-o de que ocorreu o evento.
5) Se algum sinal DTMF foi detectado pelo decodificador de discagem, o próprio decodificador irá
armazenar o valor referente à tecla discada para a leitura futura.
6) O microcontrolador então estará com o valor pronto para a leitura em sua porta.
7) Por fim, a interrupção deverá ser gerada no microcontrolador.
O fluxograma contido na figura 12 se refere ao módulo Solicitador de Bloqueio.
Figura 12 - Fluxograma do Módulo Solicitador de Bloqueio do Gerenciador
A seguir, estão listados os passos do fluxograma contido na figura 12. 1) Início do fluxograma.
2) Testa se recebeu o sinal de 1 bit gerado pelo microcontrolador. Este sinal é um requerimento de
bloqueio.
3) Se o sinal foi recebido (ativação do bit 7 da porta P1 do microcontrolador), um transistor é
polarizado, ativando um relé, que está configurado para a tensão da linha telefônica cair para 5V.
3.1.1.1. Memória Externa do Microcontrolador
O microcontrolador 8051 deve armazenar todos os telefonemas e suas devidas
informações em uma memória externa. Desta forma, quando o administrador do sistema
desejar visualizar as novas chamadas, o microcontrolador envia estas informações ao PC que
irá armazenar no seu banco de dados.
O microcontrolador 8051 possui suporte a esta memória externa e possui 2 portas de 8
bits cada uma, destinadas a endereçamento da memória externa. Outra porta também é
utilizada para o acesso de leitura ou escrita as posições da memória.
A memória externa escolhida é uma RAM 64K x 8, ou seja, possui 65536 posições de 8
bits cada uma, podendo armazenar assim 64 Kbytes de dados. Porém, um bit de acesso à
memória externa, o bit de endereço 15, é reservado para ativar um dispositivo, ou a memória.
A capacidade da memória externa cai então para 215, totalizando 32K posições de 8 bits.
A memória do microcontrolador foi dividida em 2 partes de tamanhos variáveis. A
primeira (0000h – 15DFh) se destina aos telefones bloqueados e a segunda (15E0h – 7FFFh)
se destina ao armazenamento dos telefonemas, ou das tentativas destes.
O formato dos telefones é XXX-XXXX (por exemplo, 222-9999) para números de 7
dígitos, XXXX-XXXX (por exemplo, 2929-9292) para números de 8 dígitos, XXX-XX-
XXX-XXXX (por exemplo, 021-41-222-9999) para as ligações interurbanas de sete dígitos e
XXX-XX-XXXX-XXXX (por exemplo, 021-41-2929-9292).
Cada telefone bloqueado pode possuir no máximo 13 dígitos (pior caso). Porém, cada
telefone deverá ser separado do outro, tendo que possuir assim um espaço entre cada número
telefônico (o byte F0h), tornando o número máximo de bytes requisitados por cada número
telefônico, 14 bytes. Cada dígito destes necessita de 1 byte para armazenamento (padrão
ASCII) na memória. Desta forma, para a memória ser completamente preenchida com
números telefônicos bloqueados, considerando o pior caso cada um (14 bytes), pouco mais de
2300 telefones poderiam ser armazenados. Um exemplo, demonstrando o armazenamento de
um número telefônico bloqueado, pode ser visto na figura 13.
Figura 13 - Exemplo de um número telefônico bloqueado armazenado
Quando uma chamada é feita, o sistema armazena as informações dela. Estas
informações são: número do telefone discado, tempo de início da ligação, status da ligação (B
– Bloqueado ou C – Completada) e tempo de fim da ligação. O número telefônico, comentado
anteriormente, pode ocupar no máximo 14 bytes, sendo um byte destes 14 o separador. Os
tempos inicial e final requerem 8 bytes para serem armazenados.
Então a quantidade de bytes necessária para armazenar uma chamada é de 14 bytes do
número do telefone, para o pior caso, 1 byte de status, 8 bytes de tempos inicial e final e mais
1 byte separador, totalizando 23 bytes.
Analisando um caso pior, para completar a memória com chamadas o usuário deveria
fazer pouco mais de 1400 chamadas. Se um usuário fizesse 40 chamadas telefônicas por dia,
levariam cerca de 35 dias para preencher a memória por completo.
Nota-se então que 64Kbytes são suficientes para armazenar uma grande quantidade de
informações. Mas a memória deveria ser dividida entre o número de telefones bloqueados e o
número de chamadas.
O número de telefones bloqueados não pode ser muito grande, pois quando o usuário
for fazer uma chamada, o sistema pode demorar muito para verificar todos os telefones para
ver se ele a chamada é permitida ou não. Por isso, o número máximo de telefones bloqueados
é de 400, um número razoável.
Com isso a memória tem a faixa de endereçamento da posição 0 até a posição 5599
destinada para o armazenamento de telefones bloqueados. Da posição 5600 até a 32767, as
chamadas serão armazenadas, como visto na figura 14.
Figura 14 - Divisão da memória externa
3.1.1.2. Relógio do Microcontrolador
Os tempos de início e de fim da chamada devem ser armazenados para que possa
calcular a sua duração e horário de início e fim. Para isto ocorrer, foi necessária a
implementação de um relógio dentro do microcontrolador. Tal relógio deveria incrementar os
segundos de acordo com os segundos do tempo real.
Inicialmente, o relógio ia ser implementado para ser independente, ou seja, um relógio
embarcado no microcontrolador, que deveria ter suas horas, minutos, segundos, dia, mês, ano
sempre corretas. Além de ser muito complexo de ser feito, já que muitos dos recursos do
microcontrolador já estavam sendo utilizados para outras finalidades, aumentaria a
complexidade do protocolo de comunicação, que deveria possuir entradas de correção de
horário. Outro problema seria o consumo de memória, já que a hora e a data do início e do fim
de um telefonema são sempre cadastradas pelo sistema. Desta forma, seriam necessários 24
bytes para o cadastro de tais parâmetros (HH:MM:SS – 6 Bytes, DD/MM/AA – 6Bytes, para
início e fim, 24 bytes).
Um relógio mais simples então foi projetado. Tal relógio possui apenas consumo de 4
bytes, e todos são reservados para segundos. Desta forma, o relógio pode contar até 24x8
segundos, ou seja, 232 segundos, o que é suficiente para contar mais de 100 anos em segundos.
Para tal, se o software no Módulo Monitor souber quando exatamente é o início do relógio, ou
seja, em que horário e data o relógio do microcontrolador foi zerado, basta adicionar os
segundos do relógio com os do tempo real.
Por exemplo, o relógio do microcontrolador foi zerado às 19:00:00 horas do dia 20 de
janeiro de 2000. Uma chamada é feita então, com duração de 1 minuto, e cadastrada pelo
sistema. O software então recebe os dados da chamada, com o tempo inicial sendo 60, e o
tempo final sendo 120. O software, porém, sabe que o relógio foi zerado às 19:00:00 horas do
dia 20 de janeiro de 2000. Incrementando 60, que é o tempo inicial recebido de 19:00:00, tem-
se 19:00:60, que é igual a 19:01. Então, o telefonema se iniciou às 19:01:00 horas do dia 20
de janeiro de 2000. Da mesma forma para o tempo final. Incrementando 120 segundos, tem-se
que o telefonema acabou às 19:02:00 horas do dia 20 de janeiro de 2000.
Para incrementar os segundos exatamente dentro do microcontrolador foi necessária a
utilização de um dos seus timers. Um timer do microcontrolador já estava reservado para a
transmissão serial. Mas ainda sobrou outro. Então este timer que sobrou foi utilizado.
Sabe-se que cada ciclo de máquina do 8051 são 12 pulsos de clock. Com uma freqüência
de 12 MHz, cada ciclo de máquina dura 1us. Cada incremento do timer dura 1 ciclo de
máquina. Desta forma, se o timer for incrementado 50000 vezes, 50ms se passarão. Como o
timer só conta até 65535, para contar até um segundo completo, é necessário contar 20 vezes
50ms.
O timer conta crescentemente, ou seja, 0, depois 1, 2, 3, etc. Para contar 50000 vezes, é
necessário então carregar o timer com um valor inicial, no caso de 65535 subtraído de 50000,
que resulta em 15535.
Cada vez que o timer conta até 50000, um registrador é incrementado. Se este
registrador for incrementado 20 vezes, um segundo passou. E exatamente assim que o relógio
foi incrementado. Simples de implementar, e econômico em termos de espaço. Cada vez que
um registrador de 8 bytes estoura, ou seja, transita seu valor de FFh para 00h, basta
incrementar outro registrador de 8 bytes mais significativo.
A figura 15 exemplifica o sistema de relógio utilizado neste projeto.
Figura 15 - Relógio no Mi crocontrolador
3.1.1.3. Esquemáticos, Componentes e Circuitos
Os esquemáticos são, neste tópico, apresentados e comentados, com enfoque na
explicação da utilização dos componentes mostrados.
3.1.1.3.1. Decodificador DTMF
Um decodificador DTMF é um elemento que faz a conversão sinal DTMF para binário.
Isto é necessário para que o sistema possa identificar quais teclas do telefone foram
pressionadas. Como este decodificador vai ser necessário no projeto, existiam as
possibilidades de fazer a construção do mesmo ou ainda verificar a existência deste no
mercado.
Várias alternativas de componentes que fazem a decodificação de sinais DTMF foram
encontradas. Umas delas são alguns processadores digitais de sinais (DSP – Digital Signal
Processors) que possuíam suporte a este tipo de decodificação. Porém, o uso dele é mais
complexo, além de seu custo elevado, fugindo de uma das restrições do sistema (apresentada
no capítulo Especificação).
Seguindo um pouco a busca de componentes foi encontrado um componente que se
ajustava bem nas necessidades do projeto. Tal componente é o MT8870. Este componente é
de baixo custo, fácil de encontrar e de utilizar, já que é bastante usado e bem aceito no
mercado.
A figura 15 mostra um circuito simples para o funcionamento do componente MT8870.
Figura 16 - Circuito Elétrico com o MT8870
O circuito apresentado na figura 16 mostra a simplicidade do MT8870. Com este
circuito, é possível fazer a decodificação dos sinais DTMF, obtendo o valor binário nas saídas
Q0 – Q3. Quando a saída StD estiver ativada, significa que um sinal DTMF foi decodificado e
está pronto para ser lido. Invertendo este sinal, já que a interrupção somente é gerada no
microcontrolador em nível baixo ou borda de descida, o StD pode ser ligado na interrupção
externa do microcontrolador, gerando uma interrupção na medida que o usuário do telefone
está discando.
O esquemático completo do circuito decodificador DTMF pode ser encontrado em
anexo, onde se nota o uso de um transformador. O transformador é 1 para 1, ou seja, não há
qualquer tipo de transformação de amplitude do sinal. Ele é utilizado somente para realizar o
isolamento da linha telefônica com o próprio circuito.
3.1.1.3.2. Detector de Estado do Fone
O Detector de Estado do Fone é um circuito que ao colocar uma tensão na sua entrada,
sua saída alterna entre nível lógico 0 ou 1 de acordo com o estado do fone (no gancho ou fora
do gancho). Esta detecção é feita por verificar a tensão presente na linha telefônica.
Com base em experimentos e medições, a tensão usual é de aproximadamente 48V
(corrente contínua) na linha telefônica quando o fone está no gancho e não há nenhum loop da
central telefônica com algum aparelho telefônico. Quando o loop ocorre, a tensão cai para
aproximadamente 7V. Configurando o detector de nível para 24V é o suficiente para se saber
corretamente se o fone está no gancho ou fora do gancho.
Figura 17 - Circuito Elétrico do Detector de Estado do Fone
Pode-se observar na figura 17, o circuito elétrico do detector de estado do fone. A tensão de
48V mencionada anteriormente é verificada entre as entradas Linha Telefônica + e Linha
Telefônica –. O diodo zener D1 grampeia a tensão em -24V quando esta é superior à 24V. Por
exemplo, quando se tem uma tensão de 48V na entrada do zener, a tensão na saída será de
24V. Quando a tensão na entrada for de 7V, a tensão de saída do zener será de 0V.
O resistor R2 é limita a corrente de saída do zener. Existe a necessidade de limitação de
corrente por 3 fatores:
1. Assegurar que a corrente do zener não seja superior à sua corrente máxima. No
caso do zener de 24V, o componente utilizado foi o 1N4749, cuja corrente
máxima é de 10mA.
2. Assegurar que a corrente do LED (light emission diode) do fotoacoplador 4N25
não seja superior à sua corrente máxima.
3. Drenar o mínimo de corrente da linha telefônica, evitando a queda de tensão
dela.
No caso de uma linha telefônica comum (48V), a corrente pode ser calculada desta
forma:
• Quando o fone está no gancho, a tensão é de 48V. Subtraindo 24V desta tensão,
restam 24V. Através da Lei de Ohm, que diz que a tensão é igual ao produto da
resistência pela corrente (V = RI), chega-se que a corrente é igual à tensão
dividida pela corrente (I = V/R). Com o resistor R2 em 10K, tem-se uma
corrente de 24/10, que é 2,4mA.
• Quando o fone está fora do gancho, a tensão é de aproximadamente 7V. Como
7V é menor que 24V, não existirá tensão nenhuma no resistor R2, o que resulta
em nenhuma corrente circulando.
Porém, é um problema calcular exatamente a corrente, já que o fornecimento de corrente
da linha telefônica é muito limitado. Se qualquer existe qualquer carga drenando corrente, a
tensão cai. Por este motivo, o valor do resistor R2 foi encontrado experimentalmente,
colocando um potenciômetro em seu lugar. Ajustando o potenciômetro, bastou medir a tensão
da saída do fotoacoplador (neste caso no coletor), a mesma saída que vai para a interrupção
externa do microcontrolador, assegurando-se que não ficaria dentro da região linear do
transistor. Quando a tensão era de aproximadamente 5V com o fone fora do gancho e
aproximadamente 0V com o fone no gancho, a resistência do potenciômetro poderia ser
utilizada.
Outro problema que surge trabalhando com linhas telefônicas, é ter que evitar ao
máximo a geração de ruídos nela. Por este motivo que se tem o fotoacoplador no circuito, que
isola completamente a fonte e o terra usados no transistor dele, com a tensão e o terra da linha
telefônica. Dessa forma, nenhum ruído é gerado.
3.2. PROJETO DE SOFTWARE
O projeto de Software se resume na apresentação de fluxogramas no decorrer da
descrição deste tópico. O projeto de Software não conterá diagramas de classe, casos de uso,
diagramas de estado, pois este não será feito orientado a objetos. Claro que alguns recursos da
orientação a objetos serão utilizados indiretamente, pois o compilador C++ Builder possui
praticamente todos os componentes visuais orientado a objetos. Portanto alguns métodos e
atributos serão acessados através do código do Software, mas não projetados.
Os fluxogramas descrevem, em um nível alto, a funcionalidade do programa. O código
(nível mais baixo) será escrito na linguagem C++, não orientado a objetos, mas alguns
recursos da linguagem serão utilizados.
3.2.1. Software
O software é o responsável pela interface entre o usuário e o sistema. Através do
software, o usuário tem mecanismos de informar o sistema o que ele deseja e de verificar o
que o sistema cadastrou. A interface dele foi projetada para ser de fácil uso, sem necessidades
de muitos conceitos de computação, como pode ser visto na figura 18, onde o usuário estaria
cadastrando um número de telefone.
Figura 18 - Tela do Software do Módulo Monitor
Em seguida, os fluxogramas são apresentados, mostrando as principais funções do
software.
O primeiro fluxograma de software, apresentado na figura 19, descreve o funcionamento
geral do programa (módulo monitor). A explicação dos fluxogramas se dará da mesma forma
apresentada nos fluxogramas de hardware.
Figura 19 - Fluxograma Geral do Software do Módulo Monitor
A seguir, estão listados os passos do fluxograma contido na figura 19.
1) Início do Fluxograma.
2) Inicialização de variáveis diversas do programa, bem como a ligação do programa ao banco de
dados, e a alocação de memória de variáveis dinâmicas.
3) Este bloco testa se o usuário selecionou a opção de “Download de Informações Cadastradas no
Gerenciador”.
4) Este bloco testa se o usuário selecionou a opção de “Upload de números telefônicos bloqueados”.
5) Este bloco testa se o usuário selecionou a opção de “Geração de Relatório”.
6) Este bloco testa se o usuário selecionou a opção de “Sair do Programa”.
7) Este processo é o responsável por salvar os dados da interface visual do programa quando o
usuário seleciona a opção “Sair do programa” e confirma a seleção. Tais dados são: a maneira
como se apresenta os formulários, tabelas e outros componentes, o estado da janela principal
(maximizado, tamanho, etc), etc.
8) Este é o processo que se encarrega de receber as informações do microcontrolador. Ele será
descrito em um outro fluxograma específico.
9) Este é o processo que se encarrega de enviar as informações para o microcontrolador. Ele
também, como o processo de download, será descrito em um outro fluxograma específico.
10) Este processo também será referenciado futuramente em um fluxograma específico. Porém,
adiantando, é o processo que cuida da geração do relatório a partir das informações cadastradas
no banco de dados.
11) Fim do fluxograma.
Outras opções são existentes no software, mas são somente de cadastro de banco de
dados, não precisando de uma seqüência exata de passos. Desta forma, não são necessários
projetos de fluxogramas.
O fluxograma do processo de download está descrito na figura 20, e será explicado
como da mesma forma que os outros. Este processo se encarrega de receber as chamadas do
microcontrolador, e cadastrá-las no banco de dados de forma correta.
Figura 20 - Fluxograma do Processo Download do Módulo Monitor
A seguir, estão listados os passos do fluxograma contido na figura 20.
1) Início do Fluxograma.
2) O requerimento de Download para o microcontrolador é enviado, de acordo com o protocolo de
comunicações projetado.
3) Este bloco é executado checando se o PC recebeu algum novo dado.
4) Conforme os dados vão chegando, eles vão sendo armazenados em uma string para facilitar o
futuro processamento das informações, e reconhecimento das mesmas.
5) O Fim de transmissão é uma mensagem enviada pelo microcontrolador. Caso este fim tenha sido
recebido, pode-se tratar e interpretar os dados recebidos.
6) Como o fim de transmissão foi recebido, os dados recebidos são separados para a interpretação
individual.
7) Verifica se o número telefônico inicia com 0, para diferenciar uma chamada local de uma
interurbana
8) Insere no banco de dados a nova operadora.
9) Insere no banco de dados o novo DDD.
10) Insere no banco de dados o Nº Telefônico.
11) Testa se a Operadora identificada está no banco de dados.
12) Testa se o DDD identificado está no banco de dados.
13) Testa se o Nº telefônico identificado está no banco de dados. Após este passo, os dados
referentes a essa chamada são inseridos no banco de dados.
14) Testa se existe ainda mais algum número não avaliado. Se não existir acaba, se existir continua
avaliando.
15) Fim do fluxograma.
No fluxograma contido na figura 21, o processo de Upload está sendo descrito. Ele se
encarrega de enviar os números telefônicos bloqueados para o microcontrolador.
Figura 21 - Fluxograma do Processo Upload do Módulo Monitor
A seguir, estão listados os passos do fluxograma contido na figura 21.
1) Início do fluxograma.
2) Este processo prepara os dados a serem enviados para o microcontrolador previamente, evitando a
necessidade de processar queries de acesso a dados do banco de dados durante a transmissão, o que
poderia causar qualquer tipo de erro.
3) O requerimento de Upload é enviado ao microcontrolador, que se preparará para receber os dados.
4) Por fim, todos os dados são enviados ao microcontrolador utilizando os bits de controle, separadores e
outros recursos do protocolo.
5) Fim do fluxograma.
O último fluxograma descrito é o fluxograma do processo de Geração de Relatórios. Tal
fluxograma está contido na figura 22.
Figura 22 - Fluxograma do Processo Geração de Relatório
A seguir, estão listados os passos do fluxograma contido na figura 22.
1) Início do fluxograma.
2) O usuário deverá informar qual é o período (em data) que ele deseja que as chamadas realizadas
sejam exibidas.
3) Executa uma query que busca no banco de dados todas as informações que o relatório vai exibir.
4) Um formulário irá abrir na tela do computador mostrando todos estes dados em uma tabela. Esta
tabela poderá ser ordenada por qualquer campo, como por exemplo, número telefônico. Assim o
usuário irá saber quais telefones foram mais utilizados.
5) Fim do fluxograma.
Essas são as funções básicas que o software contido no PC (módulo monitor) tem. Nota-
se então que o software será muito simples, mas tem uma interface mais amigável o possível.
3.2.2. Banco de Dados
O Banco de Dados é o elemento principal de armazenamento dos dados no módulo
monitor. Através dele os dados podem ser manipulados e gerenciados, podendo assim, gerar
os relatórios que o software possibilita.
De forma a garantir a integridade dos dados no banco de dados, este deve ser bem
projetado, evitando-se problemas de integridade como inconsistência de dados. A figura 23
mostra o modelo de dados utilizado.
Figura 23 - Tabelas e Relacionamentos do Banco de Dados
O Banco de Dados foi desenvolvido no Microsoft Access, possuindo 7 tabelas
necessárias para o armazenamento dos dados. Estas tabelas são:
• TB01_Telefone : Armazena o número de telefone, o tipo e o seu DDD.
• TB02_DDD: Armazena todos os DDDs cadastrados. Por exemplo: 48 – Sul de
Santa Catarina. O código 00 para o DDD indica que o telefone é local.
• TB03_Tipo_Telefone : Armazena o tipo do telefone (0 para fixo e 1 para
móvel).
• TB04_Operadora: Armazena as operadoras cadastradas no sistema. Por
exemplo: 21 – Embratel.
• TB05_Tarifa: Através do DDD, da operadora e do tipo do telefone, pode-se ter
um valor de tarifa atribuído.
• TB06_Chamada: A tabela TB06_Chamada armazena o telefone, a tarifa e as
datas/horas do início e do fim da chamada. Através das datas/horas de início e
fim da chamada, a duração pode ser extraída e multiplicada pelo valor da tarifa,
(dividindo por 4 caso o sistema de tarifação seja de pulso – DDD 00) obtendo
assim o custo total da chamada.
• TB07_Usuário: Esta tabela armazena os usuários de telefone cadastrados.
O prefixo TBXX (onde XX é o número) foi adotado nos nomes das tabelas para que
facilite na identificação de qual tabela uma chave estrangeira se referencia, evitando o
desperdício de tempo de procurar as tabelas corretas.
3.2.3. Projeto de Comunicações
Para o funcionamento correto do sistema, o módulo gerenciador deve se comunicar com
o módulo monitor. Para que isto aconteça, uma interface de comunicação deve ser utilizada.
A princípio, a porta USB (Universal Serial Bus) foi levada em consideração, mas como
a porta serial comum ainda não está caindo em desuso, e a interface de comunicação do
microcontrolador é serial padrão RS232, é mais simples implementar usando a porta serial.
A comunicação, para ela poder acontecer e para as partes a se comunicar entender o que
está sendo transmitido, um protocolo deve ser definido para o envio e recebimento de
mensagens tanto pelo microcontrolador quanto pelo PC.
O protocolo tem seus códigos de acordo com a tabela contida na figura 24.
Valor do Byte (hexadecimal) Descrição
PC uC 01h Requerimento de Upload
PC uC 02h Requerimento de Download
PC uC 03h Requerimento de Reset de Relógio
PC uC 04h Checagem dos dados enviados
PC uC F0h Caractere separador da mensagem
PC uC 61h Fim de transmissão
Figura 24 - Protocolo de Transmissão
O campo “Valor do Byte” da tabela descreve o byte de cabeçalho da mensagem (não
incluindo o start bit nem o stop bit). A mensagem é composta por: cabeçalho, mensagem,
caractere terminador. O caractere terminador é o byte que determina fim de transmissão ou
separador de mensagem.
Quando o PC envia o 01h, indicando o requerimento de Upload, o microcontrolador
passa a aguardar os bytes até que o 61h seja enviado indicando o fim da transmissão.
Quando o PC envia o 02h, indicando o requerimento de Download, o microcontrolador
imediatamente começa a enviar os dados para o PC, que deve estar pronto para isto. Os dados
enviados pelo microcontrolador sempre seguirão esta ordem: os primeiros 4 bytes indicam o
tempo do início da chamada, os próximos bytes até o caractere ‘b’ ou ‘c’ indicam o número
que foi discado pelo usuário, os 4 bytes seguintes ao caractere ‘b’ ou ‘b’ indicam o tempo
onde o fone foi colocado no gancho, o F0h sempre vai ser encontrado, onde a mensagem é
separada, e quando chegar no último telefonema, após o F0h, virá o 61h, que indicará o fim.
O PC deve sempre enviar o 03h assim que concluir a transmissão de números
bloqueados. Recebendo este byte, o microcontrolador irá zerar os seus registradores de
relógio. O PC também deve armazenar quando que isto foi feito para poder sincronizar os
relógios, como visto no tópico Relógio do Microcontrolador.
Caso deseje ver quais números telefônicos estão bloqueados no microcontrolador, basta
enviar a ele o byte 04h. A forma como a transmissão deverá ocorrer é semelhante à forma do
02h, porém não existirão os tempos inicial e final, e os caracteres ‘b’ ou ‘c’.
4. CONCLUSÃO
Através do projeto realizado, alguns pontos se destacaram e serão citados nesta
conclusão.
O primeiro e principal ponto é a dificuldade em se trabalhar com a linha telefônica.
Circuitos eletrônicos que drenem qualquer corrente elétrica da linha telefônica podem gerar
vários problemas. Para a detecção do estado do fone, se ele está no gancho ou não, o circuito
projetado drena, apesar de pouca, alguma corrente da linha telefônica. Como a corrente
fornecida pela linha telefônica é muito limitada, a tensão varia de valor com a menor alteração
de corrente drenada, o que acaba tornando muito instável o projeto. O ideal é projetar
circuitos que não utilizem nenhuma corrente da linha telefônica, pois podem alterar a maneira
como ela se comporta.
Outro problema é a geração de ruído na linha telefônica. Para poder trabalhar com a
linha telefônica sem a geração de qualquer ruído, deve-se isolar qualquer circuito que utilize
uma fonte externa à linha telefônica. Vários componentes podem ser utilizados para isto,
como transformadores, relés e fotoacopladores. Neste projeto estes 3 componentes foram
utilizados, visando isolamento.
Projetar um sistema corretamente é de extrema importância para o desenvolvimento e
implementação deste. É necessário ter uma visão em longo prazo para poder trabalhar
eventuais problemas e para evitar outros. Porém, somente com a experiência do projetista, ou
com a experiência do responsável pela revisão do projeto isto é alcançado.
O esperado neste projeto foi alcançado, apesar de com algumas alterações da idéia
inicial. O Bloqueador de Chamadas possuiu problemas e teve que ser implementado em
conjunto com o 8051. O problema é a baixa corrente que pode ser drenada pela linha
telefônica. Poucos componentes para fazer o bloqueio podem ser utilizados por este motivo.
Com esta restrição, ficou realmente difícil projetar algo que não necessitasse de fonte de
alimentação externa.
Trabalhos que utilizem a idéia deste projeto podem ser realizados. Pelo fato de muitas
pessoas ainda não possuírem um microcomputador em casa, poderia ser interessante realizar o
projeto de um sistema completamente embarcado no hardware.
Outro ponto interessante para implementação é a disponibilidade do sistema pela
Internet. Com um servidor ligado à rede mundial de computadores, o administrador poderia
acompanhar o uso da linha telefônica, e seus gastos.
A implementação para linhas com sistema de discagem de pulsos decádicos é algo
simples de se fazer. Atendendo as interrupções externas, as mesmas geradas pelo evento
“colocar o fone no gancho”, controlando o tempo entre cada pulso, pode-se decodificar
discagens deste tipo sem a necessidade de um hardware externo.
Uma infinidade de trabalhos pode ser realizada com base neste projeto. Hoje se tem
recursos e componentes que tornam muito mais fácil a implementação, e em muitos pontos,
mais interessantes. Com imaginação e vontade, possibilidades infinitas de projetos podem ser
realizados utilizando a linha telefônica, um sistema utilizado no mundo todo.
5. REFERÊNCIAS BIBLIOGRÁFICAS
[DNI - 2000] NICOLOSI, Denys E. C. – “Microcontrolador 8051 DETALHADO”, Editora
Érica LTDA. Ano 2000, Edição 1.
[ALI - 2000] LIMA JUNIOR, Almir Wirth – “Telecomunicações Modernas, Curso
Básico”, Editora Book Express, Ano 2000, Edição 1.
[BRA – 1999] BRAGA, Newton C. – “Curso Básico de Eletrônica”, Editora Saber, Ano
1999.
[CLA - 2001] Clare Inc. – “Datasheet M-8870 DTMF Receiver”, Ano 2001.
[FA1 – 2002] Fairchild Semiconductors – “General Purpose 6-PIN Phototransistor
Optocouplers – 4N25”, Ano 2002.
[FA2 – 1997] Fairchild Semiconductors – “NPN General Purpose Amplifier”, Ano 1997.
[FA3 - 2001] Fairchild Semiconductors – “ZENERS 1N4728A - 1N4752”, Ano 2001.
6. ANEXOS ANEXO 1 - CÓDIGO FONTE DO SOFTWARE DO 8051 ANEXO 2 - ARTIGO ANEXO 3 - MANUAL TÉCNICO ANEXO 4 - MANUAL DO USUÁRIO
ANEXO 1 – Código Fonte do Software do 8051.
org 0000h ;Area de Reset sjmp lbl_Reset ;salta para o local do programa org 0003h ;area de interrupcao 0 ljmp lbl_Ext0 org 000Bh ;area de interrupcao timer 0 ljmp lbl_T0 org 0013h ;area de interrupcao externa 1 ljmp lbl_Ext1 org 0023h ;Area de interrupcao serial jb TI, lbl_Limpa_TI ljmp lbl_Serial ;chama a rotina serial lbl_Limpa_TI: clr TI reti org 30h ;area de programa lbl_Reset: clr P1.7 mov TMOD,#00100001b ;configura TMOD com timer 1 = modo 2 mov TH1,#FDh ;configura recarga automatica de timer 1 (taxa de transmissao = 19200) mov SCON,#01010000b ;configura serial no modo 1 ativando recepcao serial mov pcon,#10000000b ;ativa SMOD para a taxa de transimissao mov 2Fh, #00h ;reseta vetor de flags mov DPTR, #0000h ;reseta valor de DPTR mov A, #61h movx @DPTR, A ;resetando a area de numeros bloqueados mov DPTR, #15E0h movx @DPTR, A ;resetando a area de chamadas realizadas mov R2, #E0h ;apontando R2 e R3 para parte de chamadas realizadas (ultima chamada cadastrada) mov R3, #15h mov R4, #00h ;zerando numero de digitos mov 18h, #00h ;reseta o valor de 18h (contagem de tempo) mov 19h, #00h ;reseta o valor de 18h (contagem de tempo) mov 20h, #00h ;reseta o valor de 18h (contagem de tempo) mov 21h, #00h ;reseta o valor de 18h (contagem de tempo) mov 22h, #00h ;reseta o valor de 18h (contagem de tempo) setb tcon.6 ;ativa o timer 1 setb tcon.4 ;ativa o timer 0 setb TCON.0 ;configura interrupcao externa 0 para ser por borda setb TCON.2 ;configura interrupcao externa 1 para ser por borda mov R0, #E0h ;Configura Backup de DPTR (DPL) mov R1, #15h ;Configura Backup de DPTR (DPH) mov IE,#10010111b ;configura o vetor de interrupcao para aceitar int serial, int externa 0, int externa 1, timer 0 call fnc_LimpaMemoria sjmp $ lbl_Serial: mov A, SBUF ;recebendo o byte mov R7, A ;salvando o byte para uso posterior ; call fnc_Envia ;envia o byte recebido em A (teste) jnb 2Fh.2, lbl_VerCab ;se nao esta recebendo numero, verifica o cabecalho jmp lbl_Up lbl_VerCab: clr c subb A, #01h ;recebeu requerimento de upload do pc jz lbl_Req_Up mov A, R7 clr c subb A, #02h ;recebeu requerimento de download jz lbl_Down mov A, R7 clr c subb A, #03h ;recebeu requerimento de reset de relogio jz lbl_Reseta_Relogio
mov A, R7 clr c subb A, #04h ;recebeu requerimento de reset de relogio jz lbl_Up_Bloqueado mov A, R7 clr c subb A, #05h ;recebeu requerimento de reset chamadas jz lbl_Reset_Chamadas jmp lbl_Serial_Reti ;salta para o retorno lbl_Serial_Reti: clr RI ;limpa RI para nao gerar outra interrupcao reti ;retorna da interrupção lbl_Reset_Chamadas: mov DPTR, #15E0h ;aponta para a região de Chamadas mov A, #61h movx @DPTR, A mov R0, #E0h mov R1, #15h mov R2, #E0h mov R3, #15h call fnc_LimpaMemoria jmp lbl_Serial_Reti lbl_Up_Bloqueado: mov DPTR, #0000h ;coloca o DPTR na posicao de bloqueados lbl_Up_Bloqueado_Down: movx A, @DPTR ;recebe o valor da memória externa para upload inc DPTR call fnc_Envia ;Envia o valor da memória para a porta serial clr c subb A, #61h ;verifica se acabaram os dados jnz lbl_Up_Bloqueado_Down ;se nao acabaram, continua jmp lbl_Serial_Reti ;salta para o retorno da rotina serial lbl_Reseta_Relogio: mov 18h, #00h ;reseta o valor de 18h (contagem de tempo) mov 19h, #00h ;reseta o valor de 18h (contagem de tempo) mov 20h, #00h ;reseta o valor de 18h (contagem de tempo) mov 21h, #00h ;reseta o valor de 18h (contagem de tempo) mov 22h, #00h ;reseta o valor de 18h (contagem de tempo) jmp lbl_Serial_Reti lbl_Req_Up: mov DPTR, #0000h setb 2Fh.2 ;seta o FLAG "Recebendo Números do PC" jmp lbl_Serial_Reti lbl_Up: movx @DPTR, A ;armazena o byte na memória externa inc DPTR clr c subb A, #61h ;verifica se recebeu 'a' (f im de transmissao) jnz lbl_Serial_Reti ;se nao for 'a', sai da rotina de interrupcao clr 2Fh.2 ;como recebeu fim de transmissao, zera o flag de Recebendo ; mov A, #37h ; call fnc_Envia jmp lbl_Serial_Reti ;sai da rotina de interrupcao lbl_Dow n: ;envia as chamadas cadastradas para o PC mov DPTR, #15E0h ;coloca o DPTR na posicao de chamadas mov R7, #00h lbl_Down_Loop0: mov A, R7 clr c subb A, #05h ;verifica se ja enviou 5 'a's jz lbl_Down_0 movx A, @DPTR call fnc_Envia ;enviando os bytes inc DPTR clr c subb A, #61h jz lbl_Down_IncR7 ;se encontrou um 'a' salta para incrementar R7 mov R7, #00h ;se nao foi 'a' entao zera R7, ja que os 'a's tem q ser consecutivos
jmp lbl_Down_Loop0 ;continua enviando lbl_Down_IncR7: inc R7 ;incrementa R7 para indicar que encontrou outro 'a' jmp lbl_Down_Loop0 ;continua enviando lbl_Down_0: ; call fnc_Envia_DPTR jmp lbl_Serial_Reti lbl_Ext0: mov DPL, R0 ;restaurando valor de DPL mov DPH, R1 ;restaurando valor de DPH jb 2Fh.1, lbl_Ext0_A clr ES setb 2Fh.1 ;seta o flag "armazenando numero de telefone" mov R2, DPL ;armazenando posicao da chamada atual para a funcao ver_numero mov R3, DPH ;armazenando posicao da chamada atual para a funcao ver_numero mov A, 22h ;pegando os numeros equivalentes a segundos movx @DPTR, A inc DPTR mov A, 21h movx @DPTR, A inc DPTR mov A, 20h movx @DPTR, A inc DPTR mov A, 19h movx @DPTR, A inc DPTR mov R0, DPL ;recolocando parte baixa mov R1, DPH ;recolocando parte alta de dptr em r1 lbl_Ext0_A: inc R4 ;incrementando o numero de digitos pressionados mov P1, #0Fh ;colocando a porta P1 em modo "recepcao" mov A, P1 ;armazenando o valor contido na P1 para A anl A, #0Fh ;armazenando somente a parte baixa do numero digitado mov R7, A ;armazenando o valor obtido para uso posterior clr c subb A, #0Ah ;verificando se eh o digito 0 jz lbl_Ext0_NRec ;se for, salta para nao recuperar o valor de R7 mov A, R7 ;recupera o valor de R7 lbl_Ext0_NRec: clr c add A, #30h ;adicionando o A de 30h para aparecer os numeros em ASCII call fnc_Envia ;enviando o valor recebido pela porta seria (pode retirar) inc R4 ;incrementando numero de digitos obtidos mov DPL, R0 mov DPH, R1 movx @DPTR, A ;armazenando o valor obtido na memoria (parte de chamadas) ; call fnc_Envia_DPTR inc DPTR ;incrementando ponteiro de memória externa mov R0, DPL ;recolocando parte baixa mov R1, DPH ;recolocando parte alta de dptr em r1 call fnc_Ver_Numero ;chamando a funcao de verificacao de numero telefonico reti lbl_Ext1: jnb 2Fh.1, lbl_Ext1_Reti ;testa se tinha alguma chamada em andamento. se nao tiver, desconsidera o evento clr 2Fh.1 ;como telefone foi colocado no gancho, reseta o flag "armazenando numero de telefone" mov R4, #00h ;zerando o numero de digitos pressionados mov A, R0 clr c dec A jnc lbl_Ext1_1 clr c mov A, #00h dec R1 lbl_Ext1_1: mov R0, A mov DPL, R0 mov DPH, R1 movx A, @DPTR
clr c subb A, #F0h inc DPTR mov R0, DPL mov R1, DPH jz lbl_Ext1_Reti mov A, #63h ;indica 'c' que o telefonema foi completado movx @DPTR, A inc DPTR mov A, 22h movx @DPTR, A inc DPTR mov A, 21h movx @DPTR, A inc DPTR mov A, 20h movx @DPTR, A inc DPTR mov A, 19h movx @DPTR, A inc DPTR mov A, #F0h movx @DPTR, A inc DPTR mov A, #61h movx @DPTR, A mov R0, DPL mov R1, DPH inc DPTR movx @DPTR, A jmp lbl_Ext1_Reti lbl_Ext1_Reti: setb ES reti lbl_T0: ;rotina que incrementa o relogio mov TH0, #4Bh mov TL0, #FFh inc 18h mov A, 18h clr c subb A, #14h jnz lbl_T0_Reti jb 2Fh.0, lbl_T0_Bloq lbl_T0_0: mov 18h, #00h inc 19h mov A, 19h clr c jnz lbl_T0_Reti inc 20h mov A, 20h clr c jnz lbl_T0_Reti inc 21h mov A, 21h clr c jnz lbl_T0_Reti inc 22h sjmp lbl_T0_Reti lbl_T0_Bloq: jb 2Fh.4, lbl_T0_Bloq_0 setb 2Fh.4 setb 2Fh.5 jmp lbl_T0_0 lbl_T0_Bloq_0: jb 2Fh.5, lbl_T0_Bloq_1 clr 2Fh.4 clr P1.7 clr 2Fh.0 jmp lbl_T0_0 lbl_T0_Bloq_1: clr 2Fh.5 jmp lbl_T0_0 lbl_T0_Reti:
reti fnc_Ver_Numero_Ret1: jmp fnc_Ver_Numero_Ret fnc_Ver_Numero: mov DPTR, #0000h ;move para a regiao de bloqueados movx A, @DPTR ;pega o primeiro digito da regiao de bloqueados clr c subb A, #61h ;compara com o caracter 'a' jz fnc_Ver_Numero_Ret1 ;se for, indica que nao possui numeros bloqueados, e sai da funcao mov 26h, #00h ;apontar para o primeiro numero bloqueado mov 27h, #00h mov 25h, R4 ;move para uma regiao temporaria o numero de digitos pressionados mov DPL, R2 mov DPH, R3 ;apontar para a chamada atual (a que esta sendo verificada) inc DPTR ;incrementando o DPTR em 4 para sair da regiao de "segundos" inc DPTR inc DPTR inc DPTR mov 23h, DPL ;salvando o valor de DPTR (chamada em curso) mov 24h, DPH fnc_Ver_Numero_Loop0: mov DPL, 23h ;restaurando o valor de DPTR para a chamada em curso mov DPH, 24h movx A, @DPTR ;pega o digito da chamada em curso para comparacoes inc DPTR mov 23h, DPL ;salvando nova posicao de DPTR para a chamada em curso mov 24h, DPH mov R7, A ;armazena o digito adquirido para nova comparacao mov DPL, 26h ;agora apontando para o digito da memoria de bloqueados mov DPH, 27h ;agora apontando para o digito da memoria de bloqueados movx A, @DPTR ;restaurando o digito da memoria de bloqueados inc DPTR mov 26h, DPL ;armazenando DPTR que aponta para a memoria de bloqueados mov 27h, DPH ;armazenando DPTR que aponta para a memoria de bloqueados mov R5, A ;salva o valor pego clr c subb A, #41h ;verifica se é 'A', ou seja, operadora jz fnc_Ver_Numero_Loop0 mov A, R5 clr c subb A, R7 ;verificando se os numeros sao iguais jnz fnc_Ver_Numero_Prox ;se nao forem iguais, procura o proximo numero bloqueado da memoria de bloqueados movx A, @DPTR ;se forem, verifica se o proximo digito é F0 clr c subb A, #F0h clr c jnz fnc_Ver_Numero_Loop0 ;se o proximo digito nao for F0, compara o proximo jmp fnc_Ver_Numero_Bloqueia ;se for, bloqueia o numero fnc_Ver_Numero_Prox: mov DPL, R2 mov DPH, R3 ;apontar para a chamada atual (a que esta sendo verificada) inc DPTR ;incrementando o DPTR em 4 para sair da regiao de "segundos" inc DPTR inc DPTR inc DPTR mov 23h, DPL ;salvando o valor de DPTR (chamada em curso) mov 24h, DPH mov DPL, 26h mov DPH, 27h ;Agora ira procurar pelo proximo numero para comparar fnc_Ver_Numero_Prox_Loop0: movx A, @DPTR ;Restaura o valor para verificar se eh F0 inc DPTR clr c subb A, #F0h ;verifica se eh F0 jnz fnc_Ver_Numero_Prox_Loop0 ;se nao for, verifica o proximo movx A, @DPTR ;agora restaura para verificar se eh FF clr c
subb A, #61h jz fnc_Ver_Numero_Ret ;se for FF, entao para a verif icacao: numero nao esta bloqueado ateh agora mov 26h, DPL ;salva o valor de DPTR para continuar verificando mov 27h, DPH jmp fnc_Ver_Numero_Loop0 ;vai para fnc_Ver_Numero_Loop0 para comparar com o proximo numero fnc_Ver_Numero_Bloqueia: setb 2Fh.0 ;ativa o flag Interromper Ligacao mov DPL, R0 mov DPH, R1 mov A, #62h ;indica 'b' que o telefonema foi completado movx @DPTR, A ;armazenando tempo do fim da ligacao inc DPTR mov A, 22h movx @DPTR, A inc DPTR mov A, 21h movx @DPTR, A inc DPTR mov A, 20h movx @DPTR, A inc DPTR mov A, 19h movx @DPTR, A inc DPTR mov A, #F0h ;armazenando fim da ligacao movx @DPTR, A inc DPTR mov A, #61h movx @DPTR, A mov R0, DPL mov R1, DPH inc DPTR movx @DPTR, A ;armazenando fim de numeros na memoria ; call fnc_Envia_DPTR clr 2Fh.1 setb P1.7 jmp fnc_Ver_Numero_Ret fnc_Ver_Numero_Ret: ret fnc_Envia: ;funcao de envio de 1 byte contido em A mov SBUF, A ;envia o byte contido em A jnb TI, $ ;espera o byte ser totalmente enviado clr TI ;limpa TI para nao gerar outra interrupção ret ;retorna da função de envio fnc_LimpaMemoria: ;funcao que limpa a memoria de chamadas para nao ocorrer bloqueios indevidos mov DPTR, #15E0h ;coloca dptr na posicao de chamadas fnc_LimpaMemoria_0: mov A, #61h ;prepara para armazenar 61 na mem externa movx @DPTR, A ;envia 61 na mem externa inc DPTR ;incrementa o dptr para apontar para a proxima regiao mov A, DPH ;move parte alta de DPTR para A para verificar se chegou ao fim da memoria clr c subb A, #7Fh ;verifica se parte alte eh 7Fh jnz fnc_LimpaMemoria_0 ;se nao for, continua limpando memoria mov A, DPL ;move parte baixa de DPTR para A para verificar se chegou ao fim da memoria clr c subb A, #FFh ;verifica se parte baixa eh FFh jnz fnc_LimpaMemoria_0 ;se nao for, continua limpando memoria jmp fnc_LimpaMemoria_Ret ;se for 7FFF, para de limpar fnc_LimpaMemoria_Ret: ret fnc_Envia_DPTR: ;funcao de envio de DPTR em ASCII (para debug) mov A, #F0h call fnc_Envia call fnc_Envia call fnc_Envia
mov A, DPH anl A, #F0h ;realiza AND para ficar com a parte alta clr c swap A ;coloca a parte alta na parte baixa mov R7, A ;salva o valor de A clr c subb A, #0Ah jc fnc_Envia_DPTR_0 mov A, R7 add A, #07h mov R7, A fnc_Envia_DPTR_0: clr c mov A, R7 add A, #30h ;soma com 30h para transformar para ASCII call fnc_Envia ;envia parte alta de DPH mov A, DPH anl A, #0Fh mov R7, A ;salva o valor de A clr c subb A, #0Ah jc fnc_Envia_DPTR_1 mov A, R7 add A, #07h mov R7, A fnc_Envia_DPTR_1: clr c mov A, R7 add A, #30h call fnc_Envia ;envia parte baixa de DPH mov A, DPL anl A, #F0h clr c swap A mov R7, A ;salva o valor de A clr c subb A, #0Ah jc fnc_Envia_DPTR_2 mov A, R7 add A, #07h mov R7, A fnc_Envia_DPTR_2: clr c mov A, R7 add A, #30h call fnc_Envia ;envia parte alta de DPL mov A, DPL anl A, #0Fh mov R7, A ;salva o valor de A clr c subb A, #0Ah jc fnc_Envia_DPTR_3 mov A, R7 add A, #07h mov R7, A fnc_Envia_DPTR_3: clr c mov A, R7 add A, #30h call fnc_Envia ;envia parte baixa de DPH mov A, #F0h call fnc_Envia call fnc_Envia call fnc_Envia ret ;retorna da função de envio END
ANEXO 2 – Artigo
MONITOR E GERENCIADOR DE LINHA TELEFÔNICA CONTROLADO PELO MICROCOMPUTADOR
Aluno: João Candido Araujo Milasch Filho1 Orientador: Prof. Edson Pedro Ferlin1
Centro Universitário Positivo1 [email protected]
Resumo: As residências, empresas e locais de acesso a várias pessoas são vulneráveis a utilização de seus equipamentos e estrutura de forma indevida.
Controlar o uso de certos recursos pode ser muito difícil, principalmente quando o proprietário do local não está sempre presente. A má utilização tem como principal alvo o telefone, que poderá ser usado sem qualquer tipo de controle, inclusive em ligações interurbanas.
Pequenos escritórios raramente possuem controle do uso do telefone, já que as soluções existentes no mercado são muito caras e complexas para este fim. Da mesma forma uma residência. É difícil observar uma residência que possua algum tipo de central telefônica. Observando este problema, tão claro e antigo, que surgiu a idéia de um Monitor e Gerenciador de Linha Telefônica Controlado pelo Microcomputador. Ele não controlará todos os recursos de um escritório ou de uma residência, mas um recurso que é muito utilizado e muito difícil de se controlar: o telefone.
Com um microcomputador PC e um Monitor e Gerenciador de Linha Telefônica Controlado pelo Microcomputador, o controle simples da linha telefônica passa a se tornar possível, evitando possíveis problemas de custos inesperados.
1. INTRODUÇÃO
O presente artigo tem como objetivo a apresentação do Projeto Final de Engenharia da Computação do Centro Universitário Positivo, com o tema Monitor e Gerenciador de Linha Telefônica Controlador pelo Microcomputador.
O sistema descrito neste artigo é responsável por realizar a monitoração e o gerenciamento de
uma linha telefônica de um ambiente de pequeno porte, ou seja, de residências e pequenos escritórios. 2. MONITORAÇÃO DE LINHA
TELEFÔNICA A monitoração de linha telefônica proposta é
um mecanismo de informar o administrador do sistema quais telefonemas foram dados e informações sobre cada eles como data e hora do início e do fim.
Além de fornecer tais dados, o sistema estipula o custo de cada um dos telefonemas armazenados, bem como o custo total dos telefonemas.
Esta monitoração de linha telefônica é obtida através de um hardware possuidor de um sistema de processamento (microcontrolador 8051), onde um software embarcado é executado. Circuitos eletrônicos dão suporte à este hardware microprocessado.
O projeto abrange somente o sistema de discagem por Tom (ou sinal DTMF).
2.1. Funcionamento
A monitoração da linha telefônica é possível
pelo uso de um decodificador DTMF. O decodificador DTMF utilizado foi o MT8870, um decodificador DTMF com custo muito baixo e com funcionalidade simples e eficiente.
Se um usuário retira o fone do gancho de um aparelho telefônico conectado corretamente em uma linha telefônica e pressiona uma de suas teclas, se o circuito decodificador DTMF estiver instalado na mesma linha telefônica, o valor referente ao dígito pressionado pelo usuário será decodificado e transformado para um valor binário de 4 bits. Por exemplo, o valor do sinal DTMF 1 decodificado equivale ao valor 0001b. Com exceção do sinal DTMF 0 que possui o valor 1010b, todos os outros valores decodificados correspondem ao número da tecla (1 – 0001b, 2 – 0002b, etc).
Quando o decodificador DTMF identifica um número digitado e coloca o valor decodificado em sua saída, em um de seus pinos de saída é colocado o valor binário 1 (nível alto), que corresponde a 5V de tensão. Este valor então é invertido e gera uma interrupção no microcontrolador (configurada para ser gerada na
borda de descida [2]), que através de uma de suas portas de comunicação irá adquirir o número digitado. Após esta aquisição, o número é armazenado em sua memória, para que possa posteriormente ser transmitido para o microcomputador.
Quando o primeiro dígito do telefonema é pressionado pelo usuário do telefone, o microcontrolador, antes de armazenar este dígito, armazena a hora e a data de quando este evento ocorreu. Enquanto os próximos dígitos são pressionados, o microcontrolador continua armazenando-os em posições consecutivas de memória. No momento que o usuário colocar o fone no gancho, um circuito Detector de Estado do Fone (no gancho, fora do gancho) gera outra interrupção no microcontrolador, que armazena a data e hora do fim do telefonema.
O Detector de Estado do Fone identifica o estado do fone do aparelho telefônico por medir a tensão existente na linha telefônica. Se o fone está no gancho, a tensão existente na linha telefônica é de aproximadamente 48V, em linhas telefônicas normais. Quando o fone sai do ganho, a tensão cai para aproximadamente 7V. Isto é detectado por um diodo zener de 24V (1N4749) colocado em paralelo a linha telefônica. Se a tensão da linha telefônica é superior a 24V, o zener conduz a corrente elétrica. Quando a corrente elétrica é suficiente para acionar um LED (light emission diode) de um fotoacoplador, o transistor do fotoacoplador é polarizado. Configurando este transistor para inversor, quando polarizado, 0V são garantidos. Quando não polarizado, 5V. Então, quando o fone que não está no gancho (5V na saída do transistor) é colocado no gancho, a tensão de 5V passa para 0V que irá gerar uma interrupção no microcontrolador em sua borda de descida.
O fotoacoplador é necessário para isolar a linha telefônica do circuito onde o microcontrolador está. Se não houvesse o fotoacoplador, a junção da referência (terra) da linha telefônica com a referência do circuito poderia gerar um ruído na linha, o que poderia se refletir na queda de qualidade dos telefonemas.
No circuito de detecção de sinais DTMF, o mesmo isolamento também foi necessário para evitar ruídos. No caso, o isolamento foi assegurado por um transformador 1 para 1 na entrada da linha no circuito.
Os dados cadastrados no microcontrolador podem ser transferidos para o microcomputador padrão PC (Personal Computer) onde o software do sistema está instalado. O software é responsável por tratar as informações dos telefonemas realizados e mostrá-las ao usuário. É importante enfatizar que as informações são transferidas para o software no microcomputador somente quando o usuário do sistema desejar. Desta forma, a monitoração da linha é feita off-line, ou seja, desconectado do PC.
3. GERENCIAMENTO DE LINHA TELEFÔNICA
O gerenciamento proposto neste projeto é
bloquear as chamadas que o administrador do sistema não deseja que sejam realizadas. Para isto, o gerenciamento é feito pelo próprio microcontrolador.
3.1. Funcionamento
A linha telefônica possui uma tensão de
aproximadamente 48V. Quando o fone é retirado do gancho do aparelho telefônico, a tensão cai para aproximadamente 7V. Isto ocorre, pois a linha telefônica fornece uma corrente limitada. Quando o fone é retirado do gancho, passa a circular uma corrente através do aparelho telefônico. Este loop então causa a queda de tensão [1].
Caso haja algum mecanismo de abertura do loop entre a central telefônica e o aparelho telefônico, a ligação feita de dentro para fora é interrompida. É assim que uma ligação é bloqueada no sistema. Com este fim (abrir o loop) um relé é atracado. Quando atracado, a configuração “normalmente fechado” do relé é aberta, abrindo o loop.
Como o sistema trabalha off-line, o microcontrolador necessita de uma maneira para saber quais números telefônicos estão bloqueados.
O software executado no PC fornece meios de determinar quais números estão efetivamente bloqueados. Quando o administrador configurar quais números estão bloqueados, ele deve enviar as informações para o microcontrolador.
Ao enviar as informações para o microcontrolador, estas são armazenadas em sua memória. Quando um número telefônico começar a ser identificado, o microcontrolador além de armazenar, busca a existência deste número na sua memória de bloqueados. Caso ele esteja, o bloqueio é efetivado, atracando o relé por 1 segundo, o tempo necessário para bloquear. Os dados da tentativa de telefonema também são armazenados (Data e Hora de início e fim, número).
4. EXIBIÇÃO DE RELATÓRIOS
Outra função do sistema é a exibição de
relatórios, para o administrador poder ver quais foram os telefonemas e quais as tentativas de telefonemas foram dadas.
O custo então é estipulado pelo software, que irá multiplicar a duração dos telefonemas pelas suas respectivas tarifas.
Os telefonemas bloqueados não geram nenhum custo para o administrador já que são bloqueados antes de se concluírem. Os telefonemas não bloqueados geram custo.
Então, para estipulação correta do custo gerado nos telefonemas, as tarifas devem estar
configuradas corretamente. O sistema fornece este tipo de configuração. As tarifas possuem três fatores: o DDD da chamada, a Operadora, e o tipo de telefone (fixo ou móvel).
O sistema analisa os telefones não bloqueados, classificando-os em suas respectivas formas de tarifação. Por exemplo, um número telefônico recebido foi o 222-9999. Nota-se que este número telefônico discado não possui código DDD e nem Operadora pelo simples fato deste não possuir o número 0 antecedendo-o. Verifica-se também que este não é o número de um celular por não iniciar com os dígitos 91 até 99, onde 90 é chamada a cobrar. É assim que as tarifas são enquadradas nos telefonemas pelo sistema.
Caso uma tarifa não seja encontrada no sistema, ela é criada automaticamente com o custo 0. O usuário é informado então que foram gerados dados automáticos e que existe a necessidade de revisão dos dados cadastrados, e isto deve ser feito para a estipulação do custo.
Porém, com a constante mudança nos valores das tarifas, e com o número crescente de operadoras, acaba se tornando muito difícil manter o sistema sempre atualizado. Desta forma, o ideal seria implementar um sistema que possuísse um módulo cliente-servidor, onde no servidor as tarifas deveriam ser configuradas corretamente, e nos clientes, estas deveriam ser atualizadas de acordo com o servidor. Mas como isto não está no escopo do projeto, não foi implementado.
5. CONCLUSÃO
Qualquer projeto envolvendo a linha
telefônica deve ser bem projetado. Qualquer corrente drenada da linha telefônica reflete em alterações das propriedades desta. Isto pode gerar desde mau funcionamento do telefone, até o não funcionamento dele.
O circuito de detecção de Estado do Fone, neste projeto, drena alguma corrente da linha telefônica, porém não afeta em sua funcionalidade. Mas a princípio, a idéia do bloqueador era que este fosse um circuito alimentado pela própria linha telefônica. Porém atracar um relé, alimentar os componentes que fazem o controle do tempo, drenam corrente que somada à corrente drenada do detector de Estado do Fone, causam mau funcionamento da linha telefônica.
O microcontrolador 8051 apresenta fácil interface com os circuitos deste projeto e características que se adaptam à muitos outros. A sua velocidade, taxa de transmissão e recursos foram aproveitados de forma que o sistema o possuísse como elemento principal de processamento, com exceção do processador do PC.
6. REFERÊNCIAS BIBLIOGRÁFICAS
[1] A. W. Lima, “Telecomunicações Modernas,
Curso Básico”, Book Express, Ano 2000, Edição 1.
[2] D. C. Nicolosi, “Microcontrolador 8051 DETALHADO”, Érica LTDA, Ano 2000, Edição 1.
ANEXO 3 – Manual Técnico
Centro Universitário Positivo
Núcleo de Ciências Exatas e Tecnológicas
Curso de Engenharia da Computação
MANUAL TÉCNICO
MONITOR E GERENCIADOR DE LINHA TELEFÔNICA
CONTROLADO PELO MICROCOMPUTADOR
Autor: João Candido Araujo Milasch Filho
Orientador: Prof. Edson Pedro Ferlin
Curitiba
2002
Este documento se propõe a apresentar as maneiras para instalar o Monitor e
Gerenciador de Linha Telefônica Controlado pelo Microcomputador, bem como executar a
manutenção do sistema, para corrigir eventuais erros que causam mal funcionamento ou o não
funcionamento.
1. INSTALAÇÃO
Para a instalação do sistema, os seguintes passos devem ser executados:
HARDWARE
1. Instalar a fonte de alimentação no sistema.
2. Conectar um cabo telefônico.
3. Anteriormente a todas as extensões, instalar o bloqueador de chamadas.
4. Ligar o sistema.
5. Ligar o cabo serial do 8051 no Microcomputador onde o software será instalado.
SOFTWARE
1. Criar uma pasta (diretório).
2. Copiar os arquivos do software para a pasta criada, respeitando a hierarquia
apresentada. Caso o sistema operacional não seja baseado em Windows NT
(Windows NT, Windows 2000, Windows XP Professional), vá para o passo 5.
3. Caso a plataforma seja baseada em Windows NT (Windows NT, Windows 2000,
Windows XP Professional) copiar o arquivo de nome “Userport.sys” para a pasta
onde o Windows está instalado, em sua subpasta System (Exemplos:
c:\WINNT\SYSTEM, c:\Windows\System).
4. Executar o arquivo Userport.exe, obtendo a tela na figura 1. Clicar no botão Start e
depois exit.
Figura 25 - Tela do Userport
5. Executar o sistema.
Ao iniciar o sistema pela primeira vez, deve-se:
1. 1. Conectar o gerenciador ao monitor com o cabo serial
2. 2. Executar o software.
3. 3. Selecionar a opção Sincronizar do menu Gerenciador
2. MANUTENÇÃO
Caso haja algum problema destes listados, proceder aos seguintes passos.
1. LED do kit 8051 não acende, ficando desligado.
1.1. Verifique a alimentação do kit.
1.2. Verifique a fonte de alimentação.
2. Sistema não bloqueia as chamadas..
2.1. Verifique se o sistema está ligado corretamente.
2.2. Execute o sistema, reenvie os dados para o microcontrolador, assegurando-
se que o cabo serial está instalado corretamente.
2.3. Verifique a configuração da Porta Serial no sistema (COM1 ou COM2).
2.4. Assegure que o Userport foi instalado corretamente.
2.5. Pressione o Reset do kit.
3. Sistema gerou erro de time-out quando as chamadas foram baixadas.
3.1. Verifique se o sistema está ligado corretamente.
3.2. Verifique se o cabo serial está conectado corretamente.
3.3. Verifique a configuração da Porta Serial no sistema (COM1 ou COM2).
3.4. Pressione o Reset do kit.
4. Apenas um número telefônico errôneo e grande foi cadastrado.
4.1. Verifique a conexão com o INT1 do KIT 8051.
4.2. Pressione o Reset do kit.
5. Os horários estão totalmente errados.
5.1. Sincronize o gerenciador utilizando o software, como descrito
anteriormente.
ANEXO 4 – Manual do Usuário
Centro Universitário Positivo
Núcleo de Ciências Exatas e Tecnológicas
Curso de Engenharia da Computação
MANUAL DE USUÁRIO
MONITOR E GERENCIADOR DE LINHA TELEFÔNICA
CONTROLADO PELO MICROCOMPUTADOR
Autor: João Candido Araujo Milasch Filho
Orientador: Prof. Edson Pedro Ferlin
Curitiba
2002
Este documento se propõe a apresentar as funções do sistema mostrando os passos
necessários para este sistema funcionar de acordo com as necessidades do usuário.
1. BLOQUEIO DE TELEFONES
Para bloquear números de telefones, execute os seguintes passos.
1. Execute o software do sistema.
2. Conecte o cabo serial ao KIT 8051.
3. Configure no software a porta serial utilizada (COM1 ou COM2) através do menu
Configurações, item Porta Serial.
4. Selecione a opção cadastro do menu principal, selecionando o item Números
Telefônicos.
5. Caso o número a ser bloqueado já esteja cadastrado, selecione-o e clique no botão
E (Editar), selecione a opção Bloqueado e selecione Aplicar.
6. Caso o número não esteja cadastrado, clique no botão ‘+’, insira os dados
corretamente, selecione Aplicar.
7. Caso o número não possua um DDD cadastrado, selecione o item DDDs do menu
Cadastro, clique no botão ‘+’ e insira os dados.
8. Após fornecer todos os dados de todos os telefones que se deseja bloquear,
selecione Gerenciador no menu principal, e depois o item Enviar Números
Bloqueados.
2. VERIFICAR TELEFONES CADASTRADOS
Para bloquear números de telefones, execute os seguintes passos.
1. Execute o software do sistema.
2. Conecte o cabo serial ao KIT 8051.
3. Configure no software a porta serial utilizada (COM1 ou COM2) através do menu
Configurações, item Porta Serial.
4. Selecione o menu Gerenciador e depois o item Receber Chamadas Realizadas.
5. Ao receber Fim de Transmissão, um relatório será exibido com os números
recebidos.
6. Caso obtenha uma mensagem informando que dados foram cadastrados
automaticamente, atualize-os através do menu cadastro, verificando todas as
opções (DDDs, Operadoras, Números Telefônicos).
3. CONFIGURAÇÃO DE TARIFAS
Para realizar a configuração das tarifas:
1. Certifique-se que a operadora da tarifa a ser cadastrada já está cadastrada, através
do menu Cadastro e do item Operadoras.
2. Selecione o item Tarifas no menu Cadastro.
3. Clique no botão ‘+’ para adicionar a nova tarifa.
4. Preencha os dados corretamente.
5. Clique no botão Aplicar.
6. Certifique-se que o sistema de tarifação local está configurado corretamente no
menu Configurações, item Tarifação Local.
4. EXIBIÇÃO DE RELATÓRIOS
Para realizar a exibição dos relatórios que contém informações sobre as chamadas
realizadas:
1. Selecione o item Exibir Relatório no menu Relatórios.
2. Selecione o período de exibição.
3. Selecione o botão OK.
5. LIMPAR RELATÓRIOS
Para apagar as informações antigas ou desatualizadas dos relatórios:
1. Selecione o item “Limpar Todas as Chamadas” do menu Relatórios.
2. Confirme caso tenha certeza.