Emulador RFID

Emulador de cartão EM Marine





Certamente cada um de nós que já esteve em escritórios comuns estava interessado em como esses passes sem contato funcionam. Neste artigo, vamos lidar com o princípio de operação de cartões sem contato e fazer um emulador de literalmente três componentes de rádio.



Tecnologia RFID





O aparecimento de etiquetas



RFID RFID (Inglês Radio Frequency IDentification, radio freqüência identificação) - tem uma faixa de freqüência bastante ampla e um número bastante grande de padrões diferentes que são de alguma forma aplicáveis ​​a esta tecnologia. Para referência: as frequências usadas são: 125-135 kHz, 400 kHz, 6,78 MHz, 13,56 MHz (cartões de metrô e cartões bancários), 27,125 MHz, 40,68 MHz, 433,29 MHz, 869 MHz, 915 MHz, 2,45 GHz, 5,8 GHz e 24,125 GHz. Como você pode ver, a faixa de frequência é muito ampla.



Falaremos sobre as placas mais difundidas e menos protegidas da faixa de freqüência de 125 kHz. Vou analisar o padrão EM Marine 4102, pois é o que estou mais familiarizado. No entanto, o código do emulador permite que você trabalhe com outros padrões operando a 125 kHz.



Para que possamos nos aprofundar mais na teoria, algumas palavras devem ser ditas sobre como o RFID funciona. Mais adiante no texto, serão fornecidas informações relacionadas ao padrão marinho EM 125 kHz, outras soluções RFID são organizadas de forma semelhante.





O leitor, além da troca de informações, fornece energia. A tag é uma ROM que é alimentada por um campo eletromagnético e, após a aplicação da energia, ela simplesmente fornece as informações registradas.





Este diagrama mostra claramente como o transmissor e o receptor estão dispostos. Ambos os circuitos oscilatórios são sintonizados em ressonância e são usados ​​para transmissão de dados e transmissão de energia, para alimentar um tag passivo, que é o nosso cartão.



Mais detalhes sobre o princípio de operação podem ser encontrados em [1]





O interior do cartão desmontado



Se você desmontar o cartão, poderá ver uma antena em forma de bobina e um chip preenchido com um composto, que contém uma ROM e um capacitor de 75 pF.



Descrição do protocolo EM4102



Antes de prosseguirmos, vamos entender o padrão EM4102 que iremos emular. A etiqueta RFID compatível com EM4102 contém 64 bits de memória somente leitura. Na verdade, essa é a ROM, ou seja, a informação pode ser lida dela, mas não pode ser alterada ou gravada, ou seja, esse chip é costurado uma vez na fábrica. A estrutura da memória do tag pode ser vista na figura abaixo.





Quando a etiqueta entra em um campo eletromagnético emitido por um leitor RFID, ela recebe energia do campo (potência) e começa a transmitir dados. Os primeiros 9 bits são lógicos. Esses bits são usados ​​como uma sequência de tokens para indicar o início da transmissão. Como todos os outros dados usam paridade, essa sequência de nove bits não ocorrerá mais em nenhum outro lugar. Então, existem 10 grupos de 4 bits de dados e 1 bit de paridade para cada grupo. Finalmente, existem 4 bits de checksum e o último bit de parada, que é sempre zero.



A tag repete o ciclo de transferência de dados enquanto recebe energia. Portanto, observamos uma leitura constante da tag no leitor.



Vou dar um exemplo dos dados transmitidos pela etiqueta com o número: 0x06É o número da versão e 0x001259E3 são os dados.





A propósito, o número impresso no cartão pode ser traduzido em um número hexadecimal que o leitor receberá. Por exemplo, o número está escrito no cartão: 116,23152



  • 116 em notação decimal é 0x74 em hexadecimal;
  • 23152 em decimal é 0x5A70 em hexadecimal;


Ao combiná-los, obtemos o número de série do cartão, que o leitor nos fornecerá: 0x00745A70 .



Modulação de sinal



A transmissão de dados do tag para o leitor é realizada modulando o sinal da portadora do leitor (em nosso caso, a frequência da portadora é 125 kHz). Observe que esta frequência portadora também fornece energia e modula o sinal. Para começar, vamos considerar um esquema simplificado de interação entre um leitor e uma tag. Lembre-se desta imagem, iremos consultá-la mais tarde.





Como você pode ver, o tag possui um circuito oscilatório LC, um diodo que serve para retificar a corrente alternada, um capacitor para suavizar a ondulação (isso faz parte da fonte de alimentação do tag) e um transistor, controlando o qual podemos modular o sinal. No leitor, isso se refletirá em uma mudança na corrente que flui na bobina. Simplificando, ao entrar no campo do leitor, o tag consome uma corrente elétrica (aproximadamente constantemente), ao transmitir informações, ele altera o valor da corrente consumida por um transistor e assim o leitor pode receber um sinal medindo a potência consumida.



O leitor gera um campo magnético usando um modulador e uma bobina e pega o sinal modulado, então o decodifica.





Um exemplo de modulação de um sinal de portadora



Se eu não o confundi completamente, vamos mais longe. Para transmitir dados, precisamos modular o sinal. Ou seja, ele irá sobrepor os bits da informação transmitida na frequência da portadora.



Existem três esquemas de modulação populares de acordo com o padrão RFID:



  • Código Manchester
  • Código Manchester de duas fases
  • Codificação de mudança de fase


Como o padrão EM4102 usa o esquema de codificação Manchester, vamos considerá-lo. Ao modular para o protocolo EM4102, o tempo de transmissão de um bit pode ser 64, 32 ou 16 períodos da frequência da portadora (125 kHz).





Com essa codificação, a marca muda o nível de transmissão do sinal exatamente no meio do período de transmissão de um bit. A transição do nível baixo para o alto nesses momentos significa o estado lógico "1", e a transição do nível alto para o baixo, representa o estado lógico "0".





Sinal modulado real capturado na bobina do leitor.



Fazendo um emulador RFID



Bem, se você ainda está aqui e sua cabeça não está inchada com esses cálculos, então é hora de fazer um emulador RFID, de apenas duas partes. Nessa simplicidade reside o gênio. Montei o dispositivo, pegando emprestado a ideia e o código de Micah Dowty , as fotos são minhas.





Aqui está uma barata em miniatura que pode muito bem emular a tag do



site do Projeto . O código é muito interessante, pode-se dizer brilhante e lacônico (usa-se assembler). Vamos nos deter em detalhes. Vamos analisar isso. Você pode ver o código aqui .



Para começar, vamos descobrir como essa coisa geralmente funciona, embora por definição não deva funcionar, já que contradiz o diagrama de fiação usual do microcontrolador. O diagrama do dispositivo é obtido do código-fonte.





Uma bobina de indutância de cerca de 1 μH e um microcontrolador ATtiny85



Isso, senhoras e senhores, é um verdadeiro Hacking, quando o nível de compreensão das características de funcionamento do equipamento permite criar soluções técnicas que vão além dos limites indicados pelo fabricante! E funciona, verificado pessoalmente. Este é o verdadeiro significado da palavra "hacker", não se trata de hacking e roubo.



Olhando para a frente, direi que esta bobina não é suficiente para o funcionamento normal, e mesmo assim tive que fazer uma antena normal, desligar os capacitores da fonte de alimentação e um capacitor ressonante. Mas para demonstrar os princípios do trabalho, é bastante adequado.

Como funciona:



  • AVR /. /, . , . , . , . , . , .
  • AVR. , , , ( 0,1 ). AVR. , , 125!
  • . ATtiny85 2,5 . 1,8 . AVR , ...
  • , ! , , . Clock ! 125 , RFID. , !
  • ? -, . . EM4102 32 . HID FSK 4 . RFID- . « » , RFID -.
Antes de analisarmos o código deste emulador, vamos torná-lo uma antena normal. Meus experimentos com o circuito atual revelaram extrema instabilidade em seu funcionamento. Funciona muito perto do leitor e, mesmo assim, nem sempre. Portanto, primeiro eu soldei um capacitor de 0,1 uF nas pernas de alimentação do controlador, e então decidi fazer um circuito oscilatório bem grande, como em um rótulo de verdade.





A primeira modificação é um capacitor de 0,1 uF para fonte de alimentação



Criação de antena



Não há truques na criação de uma antena helicoidal, mas você ainda precisa se familiarizar com a documentação e entender a física do processo ... Não é difícil, e até um colegial pode lidar com isso, basta um pouco de paciência e perseverança.



É muito fácil montar e configurar a antena, assim como na foto de [1] .





Para calcular a antena, você precisa se lembrar de um pouco de teoria. Precisamos fazer um circuito oscilante que será sintonizado em uma frequência de 125 kHz. Vamos abrir o curso de Fundamentos Teóricos de Engenharia Elétrica e ler o que é um circuito oscilatório:

Um circuito oscilante, um circuito elétrico contendo um indutor e um capacitor no qual as oscilações elétricas podem ser excitadas.




Circuito oscilatório paralelo



Se você deixar toda a matemática e for direto ao ponto, o circuito oscilatório tem um parâmetro como a frequência de ressonância, que é determinada pela fórmula.



f=12πLC



Onde f é a frequência de oscilação, L é a indutância da bobina, C é a capacitância do capacitor.



Nesse caso, temos um parâmetro fixo - a frequência, e podemos brincar com a capacitância e a indutância. Para calcular a bobina, usaremos o documento [2] . Todos que de alguma forma vão fazer antenas para etiquetas RFID (de qualquer frequência) devem se familiarizar com isso!

Muitos artesãos, tanto para leitores quanto para emuladores (a essência não é importante), fazem bobinas redondas. Eles são mais fáceis de contar e fabricar, mas têm uma desvantagem significativa - suas dimensões lineares são maiores do que o cartão. Quero fazer um indutor em forma de retângulo, com dimensões lineares menores do que as dimensões de um cartão padrão e de forma que o dispositivo resultante tenha o tamanho de um cartão RFID padrão. Como resultado, escolho o tamanho do futuro indutor praticamente igual ao da marca atual, ou seja, cerca de 70x40 mm... Se você selecionar um capacitor de 10 nF, a indutância da bobina (da fórmula acima) deve ser 162 μH. Agora veja a documentação para calcular uma bobina retangular. Para enrolar a bobina, escolhi um fio com seção transversal de 0,2 mm. Como resultado, abrimos a seção correspondente da documentação, e a seguinte fórmula gloriosa é apresentada aos nossos olhos.





Como você pode ver, os parâmetros de espessura e largura da bobina são desconhecidos e variáveis ​​(eles se baseiam na espessura do fio de 0,2 mm), mas as estimativas gerais me deram um número de 42 voltas. Seria possível fazer várias iterações e fazer um cálculo direto e preciso, mas em nosso caso, isso vai servir.



Em seguida, é necessário fazer uma moldura de 70x40 mm para o enrolamento da bobina. Fiz de PCB e enrolei uma bobina em torno dele.





Quadro PCB







Bobina enrolada e acabada



Infelizmente, não tenho um medidor de indutância, então tive que continuar usando o método científico de puxão. Como provavelmente cometi um erro nos cálculos e no número de voltas ao enrolar a bobina, como os fiz aproximadamente e a olho nu, decidi selecionar a capacitância ressonante manualmente. Para isso, fixei a bobina no leitor de cartões, enfiei suas pontas na protoboard (“colchão com furos”), depois comecei a conectar os recipientes um a um, enquanto registrava o sinal no osciloscópio.





Primeiros passos com o capacitor ressonante



Primeiro verifiquei o capacitor de 10nF, que deve ser ressonante. Mas a amplitude do sinal caiu imediatamente em comparação com a bobina vazia. Então peguei um capacitor menor. E então passei pelos capacitores até captar a ressonância. Assim, a capacitância ressonante do capacitor foi de 3,2 nF.





Sinal sem capacitor, bobina vazia





Sinal 10 nF





1 nF, 2 nF





3 nF, 4 nF, 2,2 nF





3.2 nF



Pode ser visto que tentei diferentes opções, e ficou claro que o máximo fica em algum lugar entre 3 e 4 nF e o resultado foi um capacitor de 3,2 nF (consistindo de dois capacitores em paralelo). É isso, nosso carretel está pronto para novos experimentos.



Em geral, quero observar que uma bobina geralmente pode ser feita na forma de trilhas em uma placa de circuito impresso e, com uma pequena série de produtos, isso deve ser feito. Aqui está um exemplo de tal placa, a 125 kHz de Alexander Guthmann . Infelizmente, o site está praticamente extinto, e o autor não se comunica há muito tempo, por isso nos contentamos apenas com minhas fotos. Se alguém puder ajudar a encontrar, eu ficaria muito grato! Eu não sei o que aconteceu com ele.





Assim, fazer o emulador imediatamente na forma de uma placa de circuito impresso não é problema. Acho que tendo o manual [2] , você pode calcular isso sozinho, já que um estudante alemão de quatorze anos poderia fazer isso.



Vamos examinar o código



Vamos dar uma olhada rápida no código, que você pode ver aqui . Existe um exemplo de emulação de dois tipos de cartão, analisarei apenas o EM4102.



Em primeiro lugar, como diz o código, ao piscar o microcontrolador, precisamos piscar os bits do fusível com o valor lfuse em 0xC0 : para que o controlador seja sincronizado a partir de um gerador externo. Chamo a atenção para o fato de que qualquer piscar de controlador estará associado ao fato de que precisará ser clock de uma fonte externa, já que estamos configurando bits de fusível com geração de um gerador externo!



Todo o código é baseado em macros. Deixe-me lembrá-lo do que são macros - um programa que prepara código para compilação. Nosso programa consiste em apenas algumas instruções em assembler: rjmp, call (2 clocks), nop, ldi, out e ret (all 1 clock)! Tudo, todo o resto do código é gerado por macros dependendo da macro de número de série (definir). A peculiaridade do trabalho é que temos poucos ciclos de clock suficientes para o trabalho normal. Tente fazer algo em 32 ciclos de clock, considerando que as instruções de salto no controlador AVR levam 2 ciclos de clock. Portanto, todo o código é gerado por macros dependendo do cartão de identificação.



#define FORMAT_IS_EM4102
#define EM4102_MFR_ID		0x12
#define EM4102_UNIQUE_ID	0x3456789A


Defina que tipo de cartão estamos emulando e defina os cartões de identificação. Esta é a macro principal a partir da qual o resto do código é formado. E, tadam, macros de sua majestade.



    .macro	delay cycles
    .if \cycles > 1
    rjmp	.+0
    delay	(\cycles - 2)
    .elseif \cycles > 0
    nop
    delay	(\cycles - 1)
    .endif
    .endm


Macro de atraso, aceita o número de tiques de atraso como entrada. Uma macro recursiva bastante óbvia que executa o atraso usando o comando nop (nenhuma operação, 1 ciclo de clock) e o comando rjmp. + 0 (mover para a próxima linha, 2 ciclos de clock). Ao combinar esses comandos entre si, você pode fazer o atraso da duração desejada em compassos. Na verdade, o código não faz nada, apenas desperdiça tempo da máquina.



Se você ainda estiver pensando, vou estuprar completamente seu cérebro, mas o código é tão engenhoso que você terá de suportar.



Codificação de macro recursiva por código manchester.



    .macro	manchester bit, count=1
    .if		\count
    manchester (\bit >> 1), (\count - 1)
    .if		\bit & 1
    baseband_1
    baseband_0
    .else
    baseband_0
    baseband_1
    .endif
    .endif
    .endm

    .macro	stop_bit
    baseband_0
    baseband_1_last
    .endm


Na verdade, toda a lógica é implementada aqui. Aceita uma máscara de bits e um contador de bits como entrada. Se o contador não for zero, então nos ligamos novamente, diminuindo o contador (macro recursiva, sim). Mais adiante, no próprio corpo, há chamadas para as macros baseband_0, baseband_1 e baseband_1_last. Dependendo de qual bit temos “1” ou “0”, modulamos o sinal do código Manchester de zero a um ou de um a zero.



Lembre-se de que dei uma tabela no artigo acima, como o conteúdo do cartão é codificado, para onde vão os bits de paridade e os bits de parada no final. Portanto, nossa tarefa agora é codificar ID-tags com este método, para isso temos duas macros.



#define ROW_PARITY(n)  ( (((n) & 0xF) << 1) | \
                         (((n) ^ ((n) >> 1) ^ ((n) >> 2) ^ ((n) >> 3)) & 1) )

#define COLUMN_PARITY  ( (EM4102_MFR_ID >> 4) ^        \
                         (EM4102_MFR_ID) ^             \
                         (EM4102_UNIQUE_ID >> 28) ^    \
                         (EM4102_UNIQUE_ID >> 24) ^    \
                         (EM4102_UNIQUE_ID >> 20) ^    \
                         (EM4102_UNIQUE_ID >> 16) ^    \
                         (EM4102_UNIQUE_ID >> 12) ^    \
                         (EM4102_UNIQUE_ID >> 8) ^     \
                         (EM4102_UNIQUE_ID >> 4) ^     \
                         (EM4102_UNIQUE_ID) )


ROW_PARITY - calculando o bit de paridade em uma string de quatro bits, COLUMN_PARITY - calculando a soma de verificação de toda a mensagem.



Toda a lógica do nosso trabalho é descrita em macro em .main



        header
        manchester	ROW_PARITY(EM4102_MFR_ID >> 4), 5
        manchester	ROW_PARITY(EM4102_MFR_ID >> 0), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 28), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 24), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 20), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 16), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 12), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 8), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 4), 5
        manchester	ROW_PARITY(EM4102_UNIQUE_ID >> 0), 5
        manchester	COLUMN_PARITY, 4
        stop_bit


Bem, isto é, apenas transferimos os 9 bits do cabeçalho da mesma maneira, depois a codificação Manchester, calculando o bit de paridade para cada 4 bits, no final uma soma de verificação e um bit de parada.



Resta descobrir o que é a banda base. Para isso, temos mais uma macro wrapper (sim, quantas são possíveis, hein?).



        .macro baseband_0
        rcall	baseband30_0
        rjmp	.+0
        .endm

        .macro baseband_1
        rcall	baseband30_1
        rjmp	.+0
        .endm
        
        .macro baseband_1_last
        rcall	baseband30_1
        rjmp	main
        .endm

        .macro header
        manchester 0x1FF, 9
        .endm


Macros de banda base * - execute o código assembly: chame as funções apropriadas e, em seguida, faça uma transição para outra instrução. A macro baseband_1_last é semelhante à macro baseband_1, exceto que faz um salto incondicional não para o comando abaixo, mas para o início da função principal. Cabeçalho da macro - serve para exibir o cabeçalho de nove bits do mesmo tipo igual a um, e chama a macro Manchester com a transmissão do número e da quantidade de bits transmitidos.



A última coisa que falta analisar são as funções baseband30_0 e baseband30_1. Eles são descritos pelo seguinte código.



baseband30_0:
        ldi	r16, OUT_PINS		// 1
        rjmp	baseband30		// 2

        /*
         * Emit a 1 at the baseband layer.
         * Takes a total of 30 clock cycles, including call overhead.
         */
baseband30_1:
        ldi	r16, 0			// 1
        rjmp	baseband30		// 2
        
        /*
         * Internal routine for baseband32_0 and _1. Must use
         * a total of 24 clock cycles. (32 - 1 ldi - 2 rjmp - 3 rcall)
         */ 
baseband30:
        out	_SFR_IO_ADDR(DDRB), r16		// 1
        delay	19				// 19
        ret					// 4


Dependendo de qual função é chamada baseband30_0 ou baseband30_1, o valor do que deveria estar no pino de I / O é escrito no registrador r16: 1 ou 0. Depois disso, há uma transição incondicional para baseband30, a saída é realizada e um atraso de 19 ciclos de clock, após o qual há um retorno.



A maior mágica desse código é que ele é calculado exatamente antes de cada ciclo de clock, cada clock de transmissão do código Manchester leva exatamente tantos períodos quanto permitido pelo padrão, ou seja, 32 ciclos de clock do processador! Isso é fantasticamente brilhante, você tem que lembrar quantos compassos cada comando leva.



Vamos compilá-lo e ver como ele se parece, como todas essas macros se expandem. Compilamos com o comando make (depois de instalar avr-gcc) e desmontamos o arquivo elf resultante



00000000 __vectors:
   0:	0e c0       	rjmp	.+28     	; 0x1e __ctors_end
   2:	15 c0       	rjmp	.+42     	; 0x2e __bad_interrupt
...


Primeiro, temos vetores de interrupção, mas estamos interessados ​​apenas no primeiro salto. Já que o resto dos vetores não leva a lugar nenhum.



0000001e __ctors_end:
  1e:	11 24       	eor	r1, r1
  20:	1f be       	out	0x3f, r1	; 63
  22:	cf e5       	ldi	r28, 0x5F	; 95
  24:	d2 e0       	ldi	r29, 0x02	; 2
  26:	de bf       	out	0x3e, r29	; 62
  28:	cd bf       	out	0x3d, r28	; 61
  2a:	02 d0       	rcall	.+4      	; 0x30 main
  2c:	11 c1       	rjmp	.+546    	; 0x250 _exit


Aqui, configuramos as portas de E / S e chamamos a função principal. Um principal consiste em uma quantidade insana de chamadas para a banda base30 * e funções de salto (é assim que nosso circo infernal de macros se desenrolou).



00000030 main:
  30:	01 d1       	rcall	.+514    	; 0x234 baseband30_1
  32:	00 c0       	rjmp	.+0      	; 0x34 main+0x4
  34:	fd d0       	rcall	.+506    	; 0x230 baseband30_0
  36:	00 c0       	rjmp	.+0      	; 0x38 main+0x8
  38:	fd d0       	rcall	.+506    	; 0x234 baseband30_1
  3a:	00 c0       	rjmp	.+0      	; 0x3c main+0xc
  3c:	f9 d0       	rcall	.+498    	; 0x230 baseband30_0
  3e:	00 c0       	rjmp	.+0      	; 0x40 main+0x10
  40:	f9 d0       	rcall	.+498    	; 0x234 baseband30_1
  42:	00 c0       	rjmp	.+0      	; 0x44 main+0x14
  44:	f5 d0       	rcall	.+490    	; 0x230 baseband30_0
  46:	00 c0       	rjmp	.+0      	; 0x48 main+0x18
  48:	f5 d0       	rcall	.+490    	; 0x234 baseband30_1
  4a:	00 c0       	rjmp	.+0      	; 0x4c main+0x1c
  4c:	f1 d0       	rcall	.+482    	; 0x230 baseband30_0
...
 22e:	00 cf       	rjmp	.-512    	; 0x30 main


E assim por diante ... até voltarmos ao principal



Bem, vamos ver como é o nosso módulo de banda base.



00000230 baseband30_0:
 230:	08 e1       	ldi	r16, 0x18	; 24
 232:	02 c0       	rjmp	.+4      	; 0x238 baseband30

00000234 baseband30_1:
 234:	00 e0       	ldi	r16, 0x00	; 0
 236:	00 c0       	rjmp	.+0      	; 0x238 baseband30

00000238 baseband30:
 238:	07 bb       	out	0x17, r16	; 23
 23a:	00 c0       	rjmp	.+0      	; 0x23c baseband30+0x4
 23c:	00 c0       	rjmp	.+0      	; 0x23e baseband30+0x6
 23e:	00 c0       	rjmp	.+0      	; 0x240 baseband30+0x8
 240:	00 c0       	rjmp	.+0      	; 0x242 baseband30+0xa
 242:	00 c0       	rjmp	.+0      	; 0x244 baseband30+0xc
 244:	00 c0       	rjmp	.+0      	; 0x246 baseband30+0xe
 246:	00 c0       	rjmp	.+0      	; 0x248 baseband30+0x10
 248:	00 c0       	rjmp	.+0      	; 0x24a baseband30+0x12
 24a:	00 c0       	rjmp	.+0      	; 0x24c baseband30+0x14
 24c:	00 00       	nop
 24e:	08 95       	ret


No final, você pode ver como o atraso se expandiu em uma lista de pulos e nop para o atraso. Esta é uma magia tão bonita.



Bem, descobrimos o código. Recolher o cérebro drenado dos ouvidos, procedemos aos testes.



Testes



Aplicaremos todo o conhecimento adquirido e realizaremos testes. Compilamos o firmware, atualizamos o controlador, lembrando de definir os bits Fuse corretamente.





Cachecol de firmware



Conectamos nosso circuito oscilatório e testamos em um leitor industrial real, sem meias medidas, condições de combate justas.





Bancada de teste



E, vejam só! Ele funciona, lê corretamente e fornece o ID correto em um loop! Sem alimentação externa, com operação somente no campo. Resta colocar tudo isso em ordem e fazer uma verdadeira etiqueta RFID.





A versão final “laminada” do rótulo



Total



Posso admitir honestamente que não acreditava totalmente que funcionaria. Fonte de alimentação do campo, modos de operação não padronizados do controlador, funcionam estritamente de acordo com os ciclos do relógio, indutor caseiro. Além do trabalho do próprio RFID. E agora, parece que um trabalho insignificante se espalha por alguns meses de leitura da documentação e debriefing. Mas funciona, e essa coisa é realmente brilhante. Então pessoal, esse tipo de coisa é hacking de verdade. Vá em frente!



Dever de casa



Como você ainda lê este artigo legal, eu o escrevi, experimentei, consegui, agora é a hora de você tentar fazer algo. O código do emulador contém uma seção que emula os cartões de proximidade HID com codificação de deslocamento de fase. Você deve entender o padrão HID e esta codificação para se divertir e assimilar melhor. Envie a solução nos comentários. Boa sorte.



Bibliografia



  1. AppNote 411 RFID Made Easy
  2. AN710 Antenna Circuit Design for RFID Applications
  3. priority1design.com





All Articles