PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ
DEPARTAMENTO ACADÊMICO DE CIÊNCIAS EXATAS
ENGENHARIA ELÉTRICA
ÊNFASE EM TELECOMUNICAÇÕES
Valquiria aparecida alcantara lima
CONTROLE DE ACESSO
COM RFID
Trabalho Acadêmico apresentado ao programa de aprendizagem de Microprocessadores e Arquitetura de Computadores II do Curso Superior de Engenharia Elétrica – ênfase Telecomunicações da Pontifícia Universidade Católica do Paraná.
Professor: Altair Olivo Santim
CURITIBA
2009
É
pensando em segurança que muitos lugares estão se utilizando da
prática do acesso apenas para pessoas autorizadas. O controle
físico de acesso pode ser obtido através de pessoas ou por
aparatos mecânicos como fechaduras e chaves; ou através de outros
meios tecnológicos, como sistemas baseados em cartões de acesso.
Atualmente, a
confiabilidade nas informações de acesso de veículos e
pedestres a condomínios ou empresas tem sido buscada visando uma maior
segurança aos moradores ou funcionários. Neste sentido, um
controle efetivo do acesso nos ambientes citados deve ser eficaz ao liberar
rapidamente os acessos permitidos e, principalmente, bloquear os acessos
indevidos. Para tanto, os equipamentos utilizados na automação
devem ser também confiáveis, com resposta rápida e
registro correto dos eventos ocorridos.
O mercado de
identificação por rádio frequência oferece diversas
soluções diferentes para a identificação. Os tags
usados para este fim, vão desde cartões e chaveiros de
proximidade, com número de identificação único.
Os equipamentos
usados nesta aplicação possuem tecnologia de
Identificação por Rádio Freqüência (RFID), com
leitura de transponders (tags) de proximidade, sem contato.
Construir um
protótipo de um sistema para controle de acesso utilizando a tecnologia
RFID para bloquear os acessos indevidos.
O projeto
propõe a criação de um controle de acesso que utiliza
o tag RFID, o qual libera o acesso
somente as pessoas autorizadas, ou seja, as que possuem o cartão com
esta tecnologia.
Devido a alta
confiabilidade das informações dos acessos pode ser utilizado em
lugares onde se faz necessário um controle específico das pessoas
que desejam adentrar.
E a segurança deste projeto
está no fato que o cartão
somente armazena um número de série e não usa
criptografia. No entanto este projeto apenas identifica o uso do Rfid,
não possui a finalidade de identificar o número de série
pré-gravado.
3.1
DETALHAMENTO DO DIAGRAMA DE BLOCOS
Sinal kHz - Usando um gerador de
função para emitir uma frequência em torno de 150kHz.
RFID – No
indutor descrito anteriormente, é encostado o cartão tag RFID de
frequência de 125kHz.
DETECTOR – O
sinal entra em um diodo detector e sai retificado e vai para um circuito RC.
Sinal retificado e Sinal sem pulsos.
FILTROS SINAL FSK
– há dois amplificadores neste estágio o primeiro funciona
como passa baixa removendo boa parte do volume da portadora e o segundo como
passa faixa extraindo o sinal FSK (onde a frequência de uma portadora
varia no tempo de acordo com os bits a transmitir).
Sinal FSK.
MICROCONTROLADOR
– o sinal que sai do ultimo amplificador pode ser conectado diretamente
ao PIC e deste extrair o sinal digital.
DECODIFICAÇÃO
SINAL FSK (SOFTWARE) – através de subrotinas que utilizam o TM R0
para marcar o tempo passado entre as mudanças detectadas na saída
do comparador..
FILTRO PASSA BAIXA
– o sinal que sai do microcontrolador é muito baixo para ser
repassado para o relé por isso utilizamos essa
configuração.
LIBERAÇÃO
DO ACESSO – circuito final que utiliza um relé que libera ou
não o acesso. Pode ser conectado a qualquer sistema seja, catraca,
fechadura elétrica ou qualquer outro dispositivo
1.
DEFINIÇÃO DOS COMPONENTES
Para a montagem do leitor foi necessário cálculos dos
componentes.
1.1.1
Indutor-antena
e do capacitor
Com a fórmula abaixo foi possível definir o valor do
indutor. Neste caso usamos fio de cobre que foi enrolado a fim de construir o
anteparo. Utilizamos para isso alfinetes presos em um papelão formando
um área quadrada 6x6cm. Valores: x=6cm, y=cm, h=1cm, b=0,3cm e o N
(números de espiras) = 34. Obtemos então 160uH.
Tendo este valor
usamos outra fórmula para definir o capacitor. Como o cartão RFID
trabalha com uma frequência de 125kHz e responde muito bem a
frequência mais altas, utilizamos nos calculos 150kHz. Conseguimos
então 10nF.
1.1.2
Detector
de Envoltória
Para operar o diodo detector necessita de um circuito auxiliar neste
caso um circuito RC. Esse vai definir a constante de tempo de descarga que
necessita ser adequada para não prejudicar a envoltória da
portadora. Com valores de R=10M e C=1n que foi definido a fim de chegar a constante abaixo.
2.
Materiais
utilizados E VALORES
|
RELAÇÃO
DE MATERIAL DO PROJETO |
|
PARA O LEITOR RFID: |
|
Resistores 4.7k,
10M, 10k, 160k, 3k, 100k, dois 1k ohms |
|
Capacitores 56n,
quatro 1n, 110p, dois 22p F |
|
Transistores 2N3904,
2N3906, VN2222LL |
|
Diodo 1N4148 |
|
Indutor (cabo de
cobre 1225cm) |
|
Amplificador: dois
TL062 |
|
Microcontrolador
PIC16F628 |
|
Cristal de Quartzo
XTAL 12MHZ |
|
Cartão RFID |
|
PARA O DRIVER |
|
Transistor TIP31C |
|
Relê 12v/10A
- 220v |
|
Diodo 1N4004 |
|
Resistores 560,
2.2k |
|
1 capacitor
de 10pF |
|
1 resistor de 630
ohms. |
3. FOTOS
Na foto 1 podemos verificar o circuito montado. A esquerda o leitor do cartão e a direita o circuito com o relé.
Foto
1.
Foto 2.
A foto 3 podemos verificar o cartão RFID (formato chaveiro) acionando indutor-antena.
Foto 3.
Foto 4.
Foto 5.
Nas fotos 4 e 5 podemos verificar os sinais no osciloscópio. Na primeira no capacitor que fica logo após o indutor-antena e na segunda na saída do microcontrolador.
Foto 6.
Na Foto 6 estamos verificando a comutação do relé usando um multímetro.
4. CIRCUITO
5. CODIGO FONTE
;****************************************************************************
include
<p16f628.inc>
__config _HS_OSC &
_WDT_ON & _LVP_OFF & _BODEN_ON & _MCLRE_ON &
_PWRTE_ON
;*****************************************************************
;** Variaveis
TempW EQU 70h ;
BitLocal EQU 71h
ContadorB EQU 72h
ProxFSR EQU 73h ;
ContadorW EQU 74h
BitContador EQU 75h
UltBitVal EQU 76h
Data0 EQU 77h ;
Final
Data1 EQU 78h
Data2 EQU 79h
Data3 EQU 7ah
Data4 EQU 62h
Zero EQU 7bh ;
Zero é
SerData EQU 7ch
Temp EQU 7dh
Output EQU 7eh
Contador EQU 7fh
TMR_amostra EQU 60h
BinCnt EQU 61h
Troca EQU 63h
#define _DIN PORTB, 7 ;
#define _DOUT PORTB, 6 ;
#define _MUX PORTB, 5 ;
#define _DE PORTB,
4
#define DecisaoVal d'170' ;
decisao, 0 = 159 , 1 = 198
;*****************************************************************
;** Programa codigo
goto Inicio
ORG 4 ;esperar
para <0004>
;interrupcao
vetor
;goto Interrupcao
ORG 5
;*****************************************************************
;******************** Programa
inicio
Inicio:
;********************* ligando WDT
;**********************
configurando TMR0, usando decod. fsk
clrwdt
bsf STATUS,
RP0
movlw b'00001111' ;Prescaler
to WDT, 1:128
movwf OPTION_REG
clrwdt
;********************* configurando
movlw b'10000010' ;Serial
port
movwf TRISB ;Set
port B I/O
movlw b'00000111'
movwf TRISA ;Set
port A I/O
bcf STATUS,
RP0
clrf PORTA
;**********************
desativar recursos exclusivos 16f628
movlw
b'00000110' ;inst
o comparador
movwf CMCON
;********************** configurando o modulo PWM 150KHz
movlw b'00001100' ;habilitar
PWM , duty = 2
movwf CCP1CON
movlw b'00000010' ;Usando
freq = 12MHz
movwf CCPR1L
movlw b'00000101' ;configurando
TMR2, Prescale = 1:4
movwf T2CON
bsf STATUS,
RP0
movlw b'00000100'
movwf PR2 ;Setando
o periodo = 4
bcf STATUS,
RP0
;********************** configurando UART
bsf STATUS,
RP0
movlw d'12' ;57600
para 12MHz Clock, alta veloc
movwf SPBRG
movlw b'10100111' ;assincrono
8 bits
movwf TXSTA
bcf STATUS,
RP0
movlw b'10110000' ;habilitar
porta serial
movwf RCSTA
clrf Zero
call EnviarString
;-----------------------
inserir Debug
goto Pular_debug
movlw 0a0h
movwf FSR
movlw b'00000011'
movwf INDF
incf FSR,
F
movlw b'11111111'
movwf INDF
incf FSR,
F
movlw b'11111100'
movwf INDF
incf FSR,
F
movlw b'00011111'
movwf INDF
incf FSR,
F
movlw b'10000001'
movwf INDF
incf FSR,
F
movlw b'11110000'
movwf INDF
incf FSR,
F
movlw b'00111110'
movwf INDF
incf FSR,
F
movlw b'00000111'
movwf INDF
incf FSR,
F
goto Decodificar_entrada
Pular_debug:
;-----------------------
esperar por comando
Esperar:
clrwdt
btfsc RCSTA, OERR
goto Limpar_erro
btfss PIR1, RCIF
goto Esperar
movfw RCREG
movwf SerData
movwf TXREG
call Espaco
movlw '1' ;Decodif
comando
xorwf SerData, W
btfsc STATUS, Z
goto Testar_amostra ;Inicio RFID
movlw '2'
xorwf SerData, W
btfsc STATUS, Z
goto DebugAmostra ;Depurar
executar, saída de dados amostrados
movlw '3'
xorwf SerData, W
btfsc STATUS, Z
goto Decodificar ;Totalmente
capturados e decodificados os
dados
movlw '4'
xorwf SerData, W
btfsc STATUS, Z
goto HexTest ;testando
routina HEX
movlw '5'
xorwf SerData, W
btfsc STATUS, Z
goto BinTest ;testando
routina bin
movlw '6'
xorwf SerData, W
btfsc STATUS, Z
goto Comando_agora ;nao
esta em uso
movlw '7'
xorwf SerData, W
btfsc STATUS, Z
goto Comando_agora
movlw '8'
xorwf SerData, W
btfsc STATUS, Z
goto Comando_agora
Comando_agora: ;Para
todos os comandos não estão em
uso
call EnviarString ;Enviar
mensagem de erro de comando
goto Esperar
;********************* limpar erro
Limpar_erro:
movfw RCREG
movfw RCREG
bcf RCSTA,
CREN
bsf RCSTA,
CREN
goto Esperar
;---------------------- comando executar
Testar_amostra: ;Comando
1: amostra de dados RFID, de 1024
bits
call Comp_verif ;
ler condicao de instalacao
movlw 0a0h
movwf FSR ;Usar
FSR para armazenamento de
dados
movlw d'80' ;Fazer
isso para 80 bytes
movwf Contador
AmostraLoop1:
call CapturarByte
incf FSR,
F ;
byte esta cheio, passar para o próximo
decfsz Contador, F
goto AmostraLoop1
;----------------------
Switch memory bank
movlw 020h
movwf FSR ;Use
FSR para armazenamento de dados
movlw d'64' ;Fazer
isso para 64 bytes
movwf Contador
AmostraLoop2:
call CapturarByte
incf FSR,
F
decfsz Contador, F
goto AmostraLoop2
;---------------------- Dados está cheio, agora liberar os dados
movlw d'80' ;fazer
para 80 bytes
movwf Contador
movlw 0a0h
movwf FSR ;Use
FSR para acessar os dados
AmostraLoop10:
movfw INDF
call EnviarBin
incf FSR,
F
decfsz Contador,
F
goto AmostraLoop10
;---------------------- Switch -banco
movlw d'64' ;fazer
para 64 bytes
movwf Contador
movlw 020h
movwf FSR ;Use
FSR para acessar dados
AmostraLoop11:
movfw INDF
call EnviarBin
incf FSR,
F
decfsz Contador,
F
goto AmostraLoop11
call NovaLinha
goto Esperar
;***********************
Comando 2 modulo debug
DebugAmostra: ;Comando
2: amostra de dados RFID, o modo
de depuração
call Comp_verif ;ler
configuracao
movlw 0a0h
movwf FSR ;Use
FSR para armazenar dados
movlw d'80' ;fazer
para 80 bytes
movwf Contador
DebugSLoop1:
call Comp_verif
movfw TMR_amostra
movwf INDF
incf FSR,
F ;byte
é cheio, passar para a próxima
decfsz Contador, F
goto DebugSLoop1
;----------------------
Switch memoria banco
movlw 020h
movwf FSR ;Use
FSR para armazenar dados
movlw d'64' ;fazer
para 64 bytes
movwf Contador
DebugSLoop2:
call Comp_verif
movfw TMR_amostra
movwf INDF
incf FSR,
F
decfsz Contador,
F
goto DebugSLoop2
;---------------------- Dados está cheio, agora liberar dados
movlw d'80' ;fazer
para 80 bytes
movwf Contador
movlw 0a0h
movwf FSR ;Use
FSR p armazenar dados
DebugSLoop10:
movfw INDF
call EnviarHex
call NovaLinha
incf FSR,
F
decfsz Contador, F
goto DebugSLoop10
;---------------------- Switch banco
movlw d'64' ;fazer
para 64 bytes
movwf Contador
movlw 020h
movwf FSR
DebugSLoop11:
movfw INDF
call EnviarHex
call NovaLinha
incf FSR,
F
decfsz Contador, F
goto DebugSLoop11
call NovaLinha
goto Esperar
;***********************
Comando 3 captura total e decodificar
Decodificar: ;Espere
seqüência de início, e
comece a captura
call Comp_verif ;ler
config.
call Esperar_ateIniciar ;esperar
para iniciar
movlw 0a0h
movwf FSR ;Use
FSR para armazenar dados
movlw d'80' ;fazer
p 80 bytes
movwf Contador
DLoop1:
call CapturarByte
incf FSR,
F
decfsz Contador,
F
goto DLoop1
;---------------------- Dados está cheio, agora liberar dados
movlw d'80'
movwf Contador
movlw 0a0h
movwf FSR
DLoop10:
movfw INDF
call EnviarBin
incf FSR,
F
decfsz Contador, F
goto DLoop10
call NovaLinha
Decodificar_entrada:
;----------------------
dados bits
movlw d'8' ;conf
para bit lido
movwf BitLocal
movlw 0a0h
movwf ProxFSR
;----------------------
iniciar extracao
clrf Data0 ;limpar
dados
clrf Data1
clrf Data2
clrf Data3
clrf Data4
clrf Troca
D_BitLoopZ:
call GetBitContador
movfw BitContador
movlw d'20'
subwf BitContador, W
btfsc STATUS, C
goto D_decodif_fim ; BitContador -
15 = Positivo, loop ja feito, pare
movlw d'7'
subwf BitContador, W
btfss STATUS, C
goto D_enviar2bit ;Negativo
1 bit
movlw '*' ;Positivo,
2 bit
call EnviarCaract
call EnviarCaract
bsf STATUS,
C
call Deslocar
call Deslocar
goto D_proxbit
D_enviar2bit:
movlw '_'
call EnviarCaract
bcf STATUS,
C
call Deslocar
D_proxbit:
movlw 0efh
subwf ProxFSR, W ;ProxFSR
- W
btfss STATUS, C
goto D_BitLoopZ ;Negative,
manter loop
call NovaLinha ;Positivo,
ProxFSR > 0xef
;-----------------------
Final dados
D_decodif_fim:
call NovaLinha
movfw Data4
call EnviarHex
movfw Data3
call EnviarHex
movfw Data2
call EnviarHex
movfw Data1
call EnviarHex
movfw Data0
call EnviarHex
call NovaLinha
goto Esperar
;***********************
Comando 4,5 Serial debug
HexTest:
call RcvHex ;Command
4: Hex test
movfw Output
call EnviarHex
call NovaLinha
goto Esperar
BinTest:
call RcvHex ;Command
5: Bin test
movfw Output
call EnviarBin
call NovaLinha
goto Esperar
;***************************** SUBROUTINA
;-----------------------------------------------------------------
Deslocar:
btfss Troca, 0
goto TrocaNotSet
rlf Data0,
F
rlf Data1,
F
rlf Data2,
F
rlf Data3,
F
rlf Data4,
F
bcf Troca,
0
return
TrocaNotSet:
bsf Troca,
0
return
;-----------------------------------------------------------------
CapturarByte:
call Comp_verif
movlw DecisaoVal ;decisao
, 0 = 159 , 1 = 198
subwf TMR_amostra, W
rlf INDF,
F ;Armazenar
os dados no endereço
apontado
call Comp_verif ;Faz
isso por 8 vezes, para encher um byte
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra, W
rlf INDF,
F
return
;-----------------------------------------------------------------
Esperar_ateIniciar:
movlw d'20'
movwf ContadorW
WTS_prox:
call Comp_verif
movlw DecisaoVal
subwf TMR_amostra,
W
btfsc STATUS, C ;Verifique
se há um valor de 0
goto Esperar_ateIniciar ;
SE 1, reinicia
decfsz ContadorW, F
goto WTS_prox ;Loop
return
;-----------------------------------------------------------------
Comp_verif:
;Process:
Loop until a
transition,
limparTMR0,
;esperar
ate a prox
transicao 0-1
SCAmostra3:
btfsc CMCON,
C1OUT
goto SCAmostra3
SCAmostra2: ;estava
baixo, esperar alto
btfss CMCON,
C1OUT
goto SCAmostra2
movfw TMR0
movwf TMR_amostra ;Store
the result in TMR_amostra
clrf TMR0 ;Limpar
TMR0 para o próximo bit
return
;-----------------------------------------------------------------
GetBitContador:
clrf BitContador
btfss UltBitVal,
0
goto OBC_ultimobit0
; goto GBC_lastbit1 ;Last
bit is a 1
OBC_loop1:
call ObterProxBit
btfss STATUS, Z
goto OBC_mod1
incf BitContador,
F ;Continue
se o valor é zero
goto OBC_loop1
OBC_mod1: ;fazer
s o bit mudar para 1
bcf UltBitVal,
0
return
OBC_ultimobit0: ;ultimo
bit é zero
GBC_loop0:
call ObterProxBit
btfsc STATUS, Z
goto OBC_mod0
incf BitContador,
F ;Continue
ise o valor é 1
goto GBC_loop0
OBC_mod0: ;fazer
s o bit mudar para 1
bsf UltBitVal,
0
return
;-----------------------------------------------------------------
ObterProxBit:
movfw ProxFSR
movwf FSR
movfw BitLocal
movwf ContadorB
decfsz BitLocal, F ;ir
para o prox bit
goto OPB_proxEtapa
movlw d'8'
movwf BitLocal
incf ProxFSR,
F ;ir
para a prox leitura
OPB_proxEtapa:
clrf TempW
bsf STATUS,
C
OPB_loop:
rlf TempW,
F ;TempW
contem máscara de bits
decfsz ContadorB ,
F
goto OPB_loop
movfw TempW
andwf INDF, W ;Resultado
em z
return
;***************************** SUBROUTINA
;-----------------------------------------------------------------
EnviarHex:
movwf Temp
swapf Temp, W
andlw 00fh
HexEsperarLoop1:
btfss PIR1, TXIF ;espere
ate o buffer esta vazio
goto HexEsperarLoop1
movwf TXREG
movf Temp, W
andlw 00fh
HexEsperarLoop2:
btfss PIR1, TXIF ;espere
ate o buffer esta vazio
goto HexEsperarLoop2
movwf TXREG
return
;-----------------------------------------------------------------
EnviarBin:
movwf Temp
movlw 8h
movwf BinCnt
BinEnviarLoop1:
btfss PIR1, TXIF ;espere
ate o buffer esta vazio
goto BinEnviarLoop1
movlw '0'
btfsc Temp, 7
movlw '1'
movwf TXREG
rlf Temp,
F
decfsz BinCnt, F
goto BinEnviarLoop1
return
;-----------------------------------------------------------------
RcvHex:
btfss PIR1, RCIF
goto RcvHex
movfw RCREG
movwf SerData
movwf TXREG ;
envia-lo d volta
movlw 30h
subwf SerData, F
movlw 10h
subwf SerData, W ;
F - W
btfsc STATUS, C ;
positivo signf - na entrada
goto Tipo1
RtnTipo1:
swapf SerData, W
movwf Output
RcvHexLoop:
btfss PIR1, RCIF
goto RcvHexLoop
movfw RCREG
movwf SerData
movwf TXREG ;
envia-lo d volta
movlw 30h
subwf SerData, F
movlw 10h
subwf SerData, W ;
F - W
btfsc STATUS, C ;
positivo signf - na entrada
goto Tipo2
RtnTipo2:
movfw SerData
iorwf Output, F
call Espaco
return
Tipo1:
movlw 07h
subwf SerData, F
movlw 10h
subwf SerData, W
btfsc STATUS, C ; Positivo significa entrada ruim
goto Tipo1E
goto RtnTipo1
Tipo1E:
movlw d'32'
subwf SerData, F
goto RtnTipo1
Tipo2:
movlw 07h
subwf SerData, F
movlw 10h
subwf SerData, W
btfsc STATUS, C ; Positivo significa entrada ruim
goto Tipo2E
goto RtnTipo2
Tipo2E:
movlw d'32'
subwf SerData, F
goto RtnTipo2
;-----------------------------------------------------------------
; LongDelay, 15 ciclos, 3ins/ciclos 22.5uS para 8Mhz clock
longo_delay:
movlw d'15'
movwf Contador
longo_delay_L:
decfsz Contador, F
goto longo_delay_L
return
;-----------------------------------------------------------------
EnviarString:
movwf Contador
EnviarLoop:
btfss PIR1, TXIF ;Espere
até buffer está vazio
goto EnviarLoop
call StringInicio
iorwf Zero, W
btfsc STATUS, Z ;Zero
é o fim da string
return
movwf TXREG
incf Contador,
F
movfw Contador
goto EnviarLoop
;-----------------------------------------------------------------
NovaLinha:
btfss PIR1, TXIF ;Espere
até buffer está vazio
goto NovaLinha
movlw 0dh
movwf TXREG
movlw 0ah
NovaLinhaLoop:
btfss PIR1, TXIF ;Espere
até buffer está vazio
goto NovaLinhaLoop
movwf TXREG
return
;-----------------------------------------------------------------
Espaco:
btfss PIR1, TXIF ;Espere
até buffer está vazio
goto Espaco
movlw ' '
movwf TXREG
return
;-----------------------------------------------------------------
EnviarCaract:
btfss PIR1, TXIF ;Espere
até buffer está vazio
goto EnviarCaract
movwf TXREG
return
;-----------------------------------------------------------------
;FIM DO PROGRAMA ..
end
REFERENCIAS
PROJETOS
BASE PARA ESTUDO
http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/s2006/cjr37/Website/index.htm.Acesso. 17/10/2009.
www.rogercom.com/.../ControleAcesso/Controle.htm.
Acesso em 21/10/2009.
EMBASAMENTO
TEÓRICO
http://www.wirelessbrasil.org/wirelessbr/colaboradores/sandra_santana/rfid_01.html.
Acesso 20/10/09
http://pt.wikipedia.org/wiki/Controle_de_acesso.
Acesso 20/10/09
http://pt.wikipedia.org/wiki/RFID.
Acesso 20/10/09