Lettore RFID - tessere e portachiavi
sul microcontrollore ATtiny13

Fonte: www.serasidis.gr
Vassilis Serasidi
Traduzione: Vadim commissionato da RadioLotsman

IN Ultimamente Vari progetti basati su chiavi RFID, utilizzati nei sistemi di sicurezza, protezione e controllo degli accessi, hanno guadagnato ampia popolarità. In alcune imprese e organizzazioni, tali sistemi, integrati con software specializzato, vengono utilizzati per registrare l'orario di lavoro, registrare le risorse materiali, ecc.

Qualsiasi sistema di identificazione a radiofrequenza (RFID) è costituito da un dispositivo di lettura (lettore, lettore o interrogatore) e da un transponder (noto anche come tag RFID, a volte viene utilizzato anche il termine tag RFID). In questo articolo vedremo un semplice dispositivo per la lettura di chiavi RFID che supporta il protocollo EM4100 e funziona ad una frequenza di 125 kHz. Questo tipo Le chiavi RFID possono avere la forma di un portachiavi o di una carta di credito (figura sotto).

Il componente principale del lettore è il microcontrollore Atmel AVR ATtiny13 , che legge il numero identificativo univoco di 10 cifre della chiave e lo invia a Codifica ASCII Di interfaccia seriale(UART) a 2400 bps al dispositivo Host. In altre parole, il lettore lo è modulo separato, collegato al processore principale o al microcontrollore del sistema (Figura 2).

Diagramma schematico Lettore RFID mostrato nella foto qui sotto:

Consideriamo le caratteristiche principali del circuito. Il microcontrollore utilizza un modulatore PWM integrato per generare un'uscita PB0 impulsi rettangolari con una frequenza di 125kHz. Se l'output PB0 è log. 0 (fronte di discesa dell'impulso), il transistor T1 è nello stato chiuso e una tensione di alimentazione di +5 V viene applicata alla bobina L1 attraverso il resistore R1. Il fronte di salita sull'uscita PB0 (log 1) apre il transistor T1 e il terminale superiore della bobina è collegato a terra. In questo momento, la bobina è collegata in parallelo al condensatore C2, formando un generatore LC (circuito oscillatorio). Il transistor commuta 125.000 volte al secondo (125 kHz). Di conseguenza, la bobina genera un segnale sinusoidale con una frequenza di 125 kHz

Il modulo lettore genera un campo elettromagnetico la cui energia viene utilizzata per alimentare la chiave RFID. Il trasferimento di energia tra la chiave RFID e il lettore si basa sul principio di funzionamento di un trasformatore convenzionale: l'avvolgimento primario del trasformatore crea una fem indotta in tutti gli altri avvolgimenti. Nel nostro caso, l'avvolgimento primario è la bobina del lettore e l'avvolgimento secondario è la bobina della chiave RFID. Gli elementi D1, C3 e R5 formano un demodulatore del segnale di modulazione di ampiezza.

Scambio dati tra chiave e lettore

Il processo di scambio dati tra la chiave RFID e il lettore è molto semplice, ma curato nei minimi dettagli. Se la chiave RFID deve trasmettere un log. 0, quindi collega un certo “carico” alla sua fonte di alimentazione, che richiede più energia trasmessa dal lettore. Ciò causerà una leggera caduta di tensione sul lato lettore; È questo livello che viene percepito dal lettore come un registro. 0

Chiave RFID caso generale trasmette 64 bit di dati nella seguente sequenza (Figura 6):

1. I primi 9 bit (sempre log. 1) sono bit di start, indicanti l'inizio dello scambio dati.
2. 4 bit - meno significativo bit significativi costume numero identificativo(D00 - D03).
3. 1 bit (P0) - bit di parità dei 4 bit precedenti.
4. 4 bit sono i bit più significativi del numero identificativo dell'utente (D04 - D07).
5. 1 bit (P1) - bit di parità dei 4 bit precedenti.
6. 4 bit - prima parte di 32 bit numero di serie Chiave RFID (D08 - D11).
7. 1 bit (P2) - bit di parità dei 4 bit precedenti.
8. Successivamente vengono trasmessi i successivi gruppi di 4 bit del numero di serie della chiave, ciascuno con un bit di parità.
9. Quindi i 4 bit di parità vengono trasmessi colonna per colonna. Ad esempio, bit di parità PC0 per i bit D00, D04, D08, D12, D16, D20, D24, D28, D32 e D36.
10. 1 bit di arresto.

Dati (sequenza a 64 bit) trasmessi dalla chiave RFID.

L'integrità dei dati viene verificata dal microcontrollore calcolando i bit di parità per ciascuna riga e colonna e confrontandoli con i dati ricevuti dalla chiave RFID.

Progettazione della bobina.

L'induttore senza cornice nel lettore con un diametro di 120 mm è avvolto con un filo di 0,5 mm di diametro e ha 58 giri, ma l'autore consiglia di aggiungere altri 2-3 giri durante l'avvolgimento. Per migliorare l'efficienza della bobina ed aumentare la distanza di lettura dei dati della chiave RFID è necessario calibrare il circuito oscillante. Se, dopo aver collegato un oscilloscopio al punto di connessione tra R1 e L1, si vedono dei picchi distorti sullo schermo del dispositivo (Figura 7), allora ciò indica la necessità di calibrare la bobina L1.

La distorsione del segnale generato dalla bobina L1 indica la necessità di calibrazione.

La calibrazione può essere eseguita in due modi dopo aver alimentato il modulo.

1. Collegare le sonde dell'oscilloscopio al punto di connessione tra R1 e L1 e, aumentando o diminuendo il numero di spire della bobina L1, eliminare la distorsione del segnale.
2. Se non si dispone di un oscilloscopio, spostare lentamente la chiave RFID sulla bobina finché la chiave non viene riconosciuta, come indicato da segnale sonoro. Se la chiave viene rilevata da una distanza di 2 cm, è necessario aggiungere/togliere più giri e poi verificare nuovamente la distanza dalla quale la chiave può essere letta con sicurezza. Utilizzando la calibrazione, l'autore dello schema ha ottenuto una lettura affidabile della chiave RFID da 3 cm.

Quando si programma il microcontrollore, è necessario impostare la seguente configurazione dei bit Fuse: byte basso 0x7A e byte alto 0x1F (il microcontrollore funziona da un generatore di clock integrato da 9,6 MHz, divisore frequenza dell'orologio disabile alle 8). Codice del programma occupa 1024 byte nella memoria del microcontrollore: viene utilizzata l'intera capacità di memoria disponibile del microcontrollore ATtiny13. Pertanto, in futuro, quando si espande la funzionalità del lettore, è meglio utilizzare un altro 8 pin Microcontrollore AVR, ad esempio ATtiny85.

Download:

Codice sorgente del programma del microcontrollore (AVRStudio 6), firmware (.hex) e schema elettrico -

Programmazione del microcontrollore

Come sapete, molti sistemi di accesso utilizzano carte RFID dello standard EM-Marin con una frequenza di 125 KHz. Il citofono di casa mia non ha fatto eccezione. Un problema: sarebbe bello imparare a copiare tali carte, perché i prezzi per copiarle non sono incoraggianti. Naturalmente ci sono parecchi schemi di fotocopiatrice online (e i cinesi vendono le loro fotocopiatrici per pochi centesimi - tuttavia, spesso inseriscono la password sui dischi durante la copia), ma perché non costruire la propria fotocopiatrice? Questo è ciò di cui tratta l'articolo qui sotto.

Vale la pena iniziare lo sviluppo di una fotocopiatrice scoprendo su cosa possono essere copiati tali segni? Dopo aver letto i forum, puoi scoprire che gli spazi vuoti più comuni per la copia sono T5577, T5557, EM4305.

Ora abbiamo bisogno di un diagramma. Prendiamo la parte analogica di tale fotocopiatrice da RECTO e colleghiamola al microcontrollore atmega8. Aggiungiamo un convertitore di livello per la connessione a una porta COM basata su max232 (chi lo desidera può usare ST232 o qualcos'altro per connettersi tramite USB, ma io ho una porta COM sul mio computer, oltre a un adattatore USB-COM, quindi è il mio compito non reggeva).

Otterrai questo diagramma:

Com'è lei? Doppio inseguitore di emettitore, circuito oscillante, rilevatore e filtri RC. Dato che i filtri RC hanno costanti di tempo diverse, confrontando i livelli di tensione tra gli stadi è possibile isolare la variazione nel segnale del tag RFID. Questo compito sarà gestito dal comparatore integrato in atmega8. La generazione di un segnale a 125 KHz sarà fornita dal controller PWM integrato in atmega8.

La combinazione di un tag RFID e di un lettore forma un trasformatore, dove il tag costituisce l'avvolgimento secondario. Le informazioni vengono trasmesse dal tag modificando il carico dell'avvolgimento secondario. Di conseguenza cambia la corrente nella bobina del lettore (avvolgimento primario). La parte analogica del circuito sopra è responsabile dell'isolamento di questi impulsi di corrente. Circuito oscillatorioè necessario configurarlo su tensione massima V punto di controllo, ad esempio, avvolgendo/avvolgendo le spire di una bobina. È vero, dicono che è meglio avere una tensione leggermente inferiore al massimo: funziona in modo più stabile. Ho circa 40 V al mio punto di prova.

Il marchio copiato utilizza la codifica Manchester. Per decifrare questo codice, è sufficiente saltare tre quarti del periodo del bit slot per qualsiasi variazione del fronte del segnale e, in base alla caduta del segnale che segue, fissare il valore del bit che corrisponderà al valore del segnale dopo la caduta. Durante la decodifica, vale la pena specificare la finestra in cui dovrebbe verificarsi la caduta del segnale, non più della metà del periodo dello slot del bit.

Ho preso il metodo per decodificare la codifica Manchester e il relativo codice da Shads. Ovviamente potevi scriverne uno tuo, ma avevo fretta di avviare la fotocopiatrice: volevo assicurarmi che il circuito funzionasse e che i tag venissero accettati. Quindi questo frammento è rimasto nel codice della fotocopiatrice. Si è anche scoperto che il mio comparatore è configurato in modo inverso rispetto a quanto richiesto dal codice di decodifica. L'ho cambiato nel codice. Quindi, abbiamo sequenze di zero e uno. Come posso ottenere il codice della carta da loro?

Ed è molto semplice. Supponiamo che il numero della carta secondo i bocconcini abbia la forma AB CD EF GH IJ. La mappa mostra questo:

1) Nove unità all'inizio;
2) Sgranocchiare A;
3) Parità Nibble A (1 bit);
4) Bocconcino B;
5) Parità Nibble B (1 bit);
…
16) Sgranocchiare I;
17) Parità Nibble I (1 bit);
18) Bocconcino J;
19) Parità Nibble J (1 bit);
20) Nibble di parità di colonna per nibble A B C D E F G H I J;
21) Bit 0.

Leggiamo tutti i 64 bit, decodifichiamo e otteniamo 40 bit del codice della carta. È logico che se emettiamo noi stessi un codice del genere, chiudendo la bobina della carta attaccata al lettore, otterremo un emulatore di carta. Ma ora non siamo interessati a lui.

Abbiamo imparato a leggere una mappa, ma come possiamo trasferire i dati sulla mappa? Per fare ciò è sufficiente attivare o disattivare la frequenza 125 KHz secondo il protocollo di comunicazione con la scheda. Durante il “silenzio” del lettore la tessera viene alimentata dall'energia immagazzinata.

I grezzi T5557/T5577 sono completamente compatibili tra loro in termini di protocolli di registrazione, tuttavia hanno valori minimi e tempi massimi impulsi (per fortuna i tempi di T5557 si sovrappongono a quelli di T5577). L'EM4305 ha un protocollo di registrazione diverso.

Per registrare T5557 ho usato il codice BolshoyK. La tabella seguente mostra i parametri del segnale per il portachiavi T5557.

La registrazione inizia con il segnale StartGape: è necessario disattivare il segnale a 125 KHz per circa 300 µs. Questo è un segnale alla carta che i dati inizieranno ora a essere trasferiti su di essa. Successivamente, dovresti trasferire le informazioni nello spazio vuoto. La codifica dei dati trasmessi è la stessa Manchester.

I grezzi T5557/T5577 e EM4305 sono multifunzionali e possono tipi diversi modulazioni, supporto password e molto altro. Ogni disco a bordo ha una serie di blocchi a 32 bit. Lo scopo di questi blocchi è diverso. Alcuni hanno un codice chiave rilasciato (ci vogliono due blocchi). In altri - configurazione. In terzo luogo, l’identificatore del produttore. Utilizzeremo funzionalità limitate, quindi chi vuole capire cosa significano tutti questi bit può guardare la documentazione per gli spazi vuoti (l'ho allegata all'archivio).

I blocchi sono raccolti in due pagine (0 e 1).

Nella pagina zero c'è un blocco di configurazione con indice 0. Questo è ciò che imposteremo. Per T5557/T5577 avremo i seguenti byte di configurazione: 0x00.0x14.0x80.0x40 secondo la tabella della documentazione (ho segnato in rosso le modalità selezionate di un bit):

Abbiamo quindi selezionato: frequenza di trasmissione dati RF/64 (125 KHz/64), codifica di tipo Manchester, blocchi di emissione fino al secondo (nei blocchi 1 e 2 avremo il codice emesso dalla carta). Prima della scrittura è necessario inviare un codice operativo (2 bit del codice operativo) e un bit di latch (lockbit). Gli opcode 10b e 11b precedono la scrittura dei dati per le pagine 0 e 1 (il bit meno significativo specifica il numero di pagina, il bit più significativo specifica il codice di scrittura della pagina). Emettiamo 10b per l'opcode (tutto il lavoro viene svolto con una pagina zero) e 0b per il bit di latch. Dopo aver trasferito tutti questi dati, è necessario trasferire l'indirizzo a tre bit della pagina da scrivere. Tutti i trasferimenti di dati per T5557/T5577 vengono eseguiti dal bit più significativo a quello meno significativo.

Impostando il codice della tessera nei blocchi 1 e 2 e la configurazione nel blocco 0, è possibile ottenere un tag RFID duplicato. Come puoi vedere, tutto è semplice.

Il prossimo tipo di grezzi è EM4305. Quindi ho dovuto occuparmi io stesso della registrazione di questo pezzo grezzo. Anch'esso è costituito da blocchi da 32 bit, ma il loro scopo è diverso.

La codifica dei dati trasmessi alla scheda si basa sulle differenze in un intervallo di tempo. Se c'era una differenza durante l'intervallo di tempo, allora sarebbe zero, altrimenti sarebbe uno. La parola di configurazione è memorizzata nel byte 4 e per conto mio l'ho definita come segue: 0x5F,0x80,0x01,0x00 (codifica Manchester, RF/64, parola di uscita 6). Nelle parole 5 e 6 scrivo il codice della carta (gli stessi 64 bit che produce la carta). EM4305 richiede che la trasmissione avvenga dal bit meno significativo a quello più significativo. La carta capisce che con lei inizia uno scambio dopo averle dato una combinazione di impulsi:

1. Spegniamo il campo a 48 µs.
2. Accendiamo il campo per 96 μs.
3. Spegnere il campo a 320 µs.
4. Accendiamo il campo a 136 μs.
5. Disabilita il campo fino al comando successivo.

Il comando per scrivere un blocco sulla mappa viene trasmesso come segue:

1. Inviamo la sequenza di impulsi di cui sopra.
2. Inviamo 0b.
3. Trasmettiamo CC0-CC1 e la loro parità P. (0101b per la registrazione, vedere le tabelle sotto).
4. Trasmettiamo l'indirizzo del blocco (vedi tabella), due zeri finali e la parità dell'indirizzo.
5. Trasmettiamo dati in blocco (32 bit).

Formato del comando

Codici di comando

Formato indirizzo blocco

Imposta la configurazione del pezzo grezzo EM4305 e il suo codice.

In realtà, una semplice fotocopiatrice non ha bisogno di altro.

Ho realizzato diverse versioni della fotocopiatrice con display diversi. Ad esempio, ecco una fotocopiatrice con display 1602:

Ed ecco un video della fotocopiatrice in funzione sul display LPH9157-02.

Il tag EM4100 memorizza 64 bit di dati, il che significa che il progetto deve contenere un registro a scorrimento a 64 bit composto da otto registri 74HC165 a 8 bit. Il registro viene azzerato dopo ogni 64 turni per azzerare i dati e ricominciare da capo. I dati agli ingressi del registro sono i seguenti:

• Schema temporale: nove unità
• ID produttore/versione: 2 blocchi da 5 bit, di cui 4 bit sono dati e il quinto è parità
• Identificatore univoco: 8 blocchi da 5 bit, di cui 4 bit sono dati e il quinto è parità
• Checksum: 4 bit di parità, contati per colonna
• Bit di stop: "0"

Anche i tag crittografati sono vulnerabili a una serie di attacchi. Inoltre, sta diventando sempre più semplice emulare i tag sugli smartphone abilitati NFC (che in genere funzionano a 13,56 MHz). Basta scrivere correttamente un'applicazione di modulazione del campo e puoi fare quello che vuoi.

Come scusa standard, lascia che ti ricordi che l'autore (E un traduttore! - Nota traduzione) non si assume alcuna responsabilità per le conseguenze dell'utilizzo delle informazioni contenute in questo articolo. Il lettore deve essere responsabile di tutte le sue azioni.

Telaio

A volte Molto fortunato. Una bella custodia potrebbe tornare utile proprio adesso, quando il prototipo sarà finito e il circuito stampato sarà stato ordinato. Fu in quel periodo che Fleming terminò l'assemblaggio e lanciò la macchina da taglio laser OSAA PhotonSaw. Dopo un anno di lavoro sul progetto, il laser è pronto per tagliare le sue prime parti. Flemming e Roon effettuano le regolazioni finali e sostituiscono il coperchio in alluminio dell'armadietto del laser. Puoi immaginare quanto fossimo tutti entusiasti di vedere questa cosa funzionare.

Con la macchina in funzione abbiamo potuto testare il nostro progetto vita reale. L'alloggiamento del nostro tag RFID era realizzato in plexiglass da 2 mm. Questo corpo è il primo oggetto realizzato su PhotonSaw, sì!

È nata l'idea di posizionare la bobina all'esterno del corpo. Inizialmente si era deciso di sfruttare la metà dell'altezza della carrozzeria, ma nella pratica ciò non ha funzionato (i fori aggiuntivi sui lati lunghi quindi non vengono utilizzati). La bobina si adatta perfettamente al perimetro dell'intero corpo, anche se avevo dei dubbi che l'avvolgimento rettangolare (105x55 mm) fosse troppo grande per la normale comunicazione elettromagnetica.

La bobina di prova è stata avvolta, senza alcun calcolo, con filo da 0,4 mm in 66 spire. E, ovviamente, siamo stati ancora una volta fortunati, perché la bobina si è rivelata esattamente come dovrebbe, con un'induttanza di 645 μH, con un tag collegato che fornisce una frequenza di risonanza di 125,2 kHz. I test su un lettore di porte hanno dimostrato che il prototipo funziona perfettamente con questa bobina.

Con la bobina esterna alla custodia è possibile ridurre lo spessore di quest'ultima. Lo spessore interno ora dipende solo dall'altezza delle parti sul pannello e, tenendo conto dello spessore del pannello, dovrebbe essere di circa 6 mm. Inoltre, sarebbe carino aggiungere qualche incisione. Flemming ha proposto di arrotondare i lati della scocca per ragioni estetiche ed ergonomiche. Un corpo curvo proteggerà meglio anche i lati della bobina, perché dove non c'è molta tensione, le spire del filo tendono a sporgere.

La macchina PhotonSaw non è ancora in perfette condizioni: incisione attiva coperchio superiore si è abbassato notevolmente. Deve essere finalizzato prima della produzione. versione finale alloggiamenti. Anche i percorsi curvi erano soggetti a errori di calcolo Software, poiché il raggio non è tornato a posizione di partenza dopo aver superato una traiettoria chiusa. Ma comunque, le curve sembrano davvero lisce.

Assemblaggio PCB

La tavola ordinata è arrivata:

Il montaggio non è stato molto difficile. La pasta saldante è stata stampata sulla tavola, tutte le parti sono state posizionate e poi saldate in un forno fatto in casa.

Attraverso la capacità di isolamento (47 pF ha una resistenza di circa 27 kOhm ad una frequenza di 125 kHz) e i diodi protettivi, la corrente viene fornita alle linee di alimentazione. L'energia proveniente dalla bobina è sufficiente a mantenere la tensione di alimentazione di circa 1 V. La corrente può raggiungere 250-500 μA. Sorprendentemente, i chip 74HC sembrano funzionare con questa alimentazione. Sfortunatamente, sotto questo tipo di tensione, accadono cose piuttosto strane. I chip 74HC hanno un circuito di reset interno ed è necessario assicurarsi che funzioni. Tieni presente che disabilitare i diodi di protezione non aiuta. Agli ingressi dei microcircuiti sono presenti diodi protettivi interni, che in questo caso si aprono e svolgono lo stesso lavoro.

Un ripristino dell'alimentazione si attiva solo se la tensione di alimentazione scende al di sotto di un determinato livello per un determinato periodo di tempo. Se la tensione rimane troppo alta, la logica interna può confondersi perché alcune parti potrebbero trovarsi in uno stato indefinito mentre altre funzionano correttamente. È necessario un ripristino interno per impostare tutti i chip su uno stato coerente. Pertanto, il circuito funzionerà instabile a tensioni di alimentazione molto basse.

Sono stati osservati i seguenti sintomi: il tag funziona per un po' di tempo, inviando dati corretti. Se la bobina viene rimossa dal lettore e poi rimessa a posto, puoi scommettere se il tag si spegnerà. A volte funziona, a volte no. Disabilitare il PLL peggiora la situazione. Il basso consumo energetico significa che il lettore riceverà occasionalmente dati da un tag spento. Questo è ciò che significa “sistema efficiente dal punto di vista energetico”.

Le soluzioni sono due: 1) ridurre il condensatore del circuito di recupero segnale dell'orologio fino a 15 pF e 2) collegare un resistore da 22-100 kOhm tra l'alimentatore e la terra per scaricare l'energia in eccesso. Il secondo metodo provoca un aumento delle perdite durante il funzionamento e non è realmente necessario quando si riduce la capacità del condensatore. Tuttavia, viene fornito come opzione ed è comunque migliore dello stato indeterminato dei chip.

Modulazione di corrente o tensione

Il modulatore portò una nuova dose di mal di testa. La modulazione scompariva completamente quando la bobina veniva posta ad una certa distanza dal lettore. Ciò potrebbe verificarsi anche avvicinando o allontanando la bobina dal lettore.

Il motivo si è rivelato essere nel circuito del modulatore. I MOSFET cortocircuitano la bobina con un resistore di una certa resistenza. Tuttavia, se il consumo di energia del circuito è elevato, la resistenza del modulatore sarà molto più elevata della resistenza dei circuiti di alimentazione. Ciò porta al fatto che la profondità di modulazione dipende dalla corrente consumata, il che non è molto buono. La situazione è stata peggiorata dalla scelta di un diodo zener limitatore in più basso voltaggio che nel prototipo.

Si è deciso di commutare il modulatore dalla modalità di modulazione di tensione alla modalità di modulazione di corrente. Nella prima modalità, il resistore era nel circuito di drain e ora è collegato tra sorgente e terra. La tensione gate-source scenderà attraverso questo resistore finché non rimarrà un valore appena al di sopra della soglia di apertura del transistor (0,9-1,1 V), che trasformerà il transistor in modalità lineare. Ora la corrente attraverso il transistor sarà stabile, indipendentemente dalla tensione di drain.

I test su un prototipo hanno dimostrato che la modulazione della corrente funziona molto bene. Il lettore economico senza nome non si blocca più (ok, forse una volta su cento circa). Possiamo supporre che questo cambiamento funzionerà meravigliosamente su altri lettori, e il tag ora probabilmente sarà in grado di funzionare sulla maggior parte di loro.

Versione finita 1

Puoi vedere le modifiche apportate su scheda a circuito stampato. Non avevo un condensatore SMD da 15 pF, dovevo saldarne uno normale con le gambe. Il modulatore ha acquisito resistori aggiuntivi sulle sorgenti dei transistor. Nel complesso accettabile per la prima versione.

(le immagini sono cliccabili)

Dimostrazione video

Conclusione

Potresti pensare che questo progetto, basato sulla logica 7400, possa essere classificato come progettazione di circuiti retrò, ma questo non è del tutto vero. Innanzitutto, la moderna famiglia 74HC non è così vecchia. In secondo luogo, i circuiti a bassa potenza sono sempre rilevanti. In terzo luogo, chip singoli elementi logici(come il trigger Schmitt utilizzato) vengono spesso utilizzati sviluppi moderni. Spesso si dimentica che lo sviluppo tecnologico non si ferma alle famiglie di chip più vecchie. Sono semplicemente diventati meno evidenti sullo sfondo della diversità generale.

La parte analogica si è rivelata più difficile da sviluppare rispetto a quella digitale. In parte a causa della mancanza di specifiche, ma soprattutto a causa dei numerosi compromessi richiesti per soddisfare i parametri e degli effetti collaterali imprevisti. I progetti digitali hanno relativamente poche opzioni, mentre quelli analogici richiedono solitamente un equilibrio tra criteri diversi (e spesso opposti).

Devo ammettere che i chip 74HC sono realizzati molto, molto bene. Gli sviluppatori sapevano cosa stavano facendo e hanno ottenuto un consumo energetico molto basso. All'inizio avevo qualche dubbio sul fatto che il tag potesse funzionare con alimentazione passiva, ma dopo aver letto le specifiche era solo questione di corretta progettazione del circuito. Anche se c'è ancora spazio per l'ottimizzazione varie parti tag.

Ora vediamo come si comporterà questo progetto al concorso 7400 del 2012. Le iscrizioni al concorso scadono il 31 novembre. Auguriamo buona fortuna all'autore! - Nota traduzione

tag:

• RFID
• Concorso 7400
• ingegneria eccessiva
• logica
• rastrella ovunque

Aggiungere etichette

Oggi parlerò del modulo RFID RC522, basato sul chip MFRC522. Alimentazione 3,3 V, campo di rilevamento fino a 6 cm. Progettato per leggere e scrivere tag RFID con una frequenza di 13,56 MHz. Frequenza in in questo casoè molto importante, poiché i tag RFID esistono in tre gamme di frequenza:

• Segni di gamma LF (125-134 kHz)


• Tag banda HF (13,56 MHz)


• Tag banda UHF (860-960 MHz)

Questo particolare modulo funziona con i tag della banda HF, in particolare con il protocollo MIFARE.

Per lavorare con il modulo è possibile utilizzare libreria standard RFID incluso IDE di Arduino, tuttavia, esiste un'altra libreria scritta appositamente per questo modulo: MFRC522 (1 MB). Entrambe le librerie sono abbastanza convenienti, ma MFRC522 ne ha di più funzioni speciali, consentendo di ridurre il più possibile il codice finale del programma.

Connessione

Alcune persone incontreranno un problema: il nome dei pin nella maggior parte delle lezioni e delle guide potrebbe non corrispondere alla piedinatura del modulo. Se gli schizzi indicano il pin SS, ma il tuo modulo non ce l'ha, molto probabilmente è contrassegnato come SDA. Di seguito fornirò una tabella di connessione dei moduli per le schede più comuni.

MFRC522	ArduinoUno	Arduino Mega	Arduino Nano v3	Arduino Leonardo/Micro	Arduino ProMicro
RST	9	5	D9	RESET/ICSP-5	RST
SDA(SS)	10	53	D10	10	10
MOSI	11 (ICSP-4)	51	D11	ICSP-4	16
MISO	12 (ICSP-1)	50	D12	ICSP-1	14
SCK	13 (ICSP-3)	52	D13	ICSP-3	15
3,3 V	3,3 V	3,3 V	Stabilizzatore 3,3 V	Stabilizzatore 3,3 V	Stabilizzatore 3,3 V
GND	GND	GND	GND	GND	GND

I pin di controllo SS(SDA) e RST sono specificati nello sketch, quindi se la tua scheda è diversa da quella che userò nei miei esempi, e sto usando UNO R3, indica i pin dalla tabella all'inizio dello sketch :

#define SS_PIN 10 #define RST_PIN 9

Esempio n.1: Lettura del numero della carta

Diamo un'occhiata ad un esempio dalla libreria RFID: cardRead. Non vengono visualizzati i dati della carta, ma solo il suo numero, che di solito è sufficiente per molte attività.

#include #include #define SS_PIN 10 #define RST_PIN 9 RFID rfid(SS_PIN, RST_PIN); // I dati sul numero della carta sono memorizzati in 5 variabili, le ricorderemo per verificare se abbiamo già letto tale carta int serNum0; int serNum1; int serNum2; int serNum3; int serNum4; void setup() ( Serial.begin(9600); SPI.begin(); rfid.init(); ) void loop() ( if (rfid.isCard()) ( if (rfid.readCardSerial()) ( // Confrontare il numero della tessera con il numero della tessera precedente se (rfid.serNum != serNum0 && rfid.serNum != serNum1 && rfid.serNum != serNum2 && rfid.serNum != serNum3 && rfid.serNum != serNum4) ( / * Se la carta è nuova, leggi */ Serial.println(" "); Serial.println("Carta trovata"); serNum0 = rfid.serNum; serNum1 = rfid.serNum; serNum2 = rfid.serNum; serNum3 = rfid .serNum; serNum4 = rfid.serNum; //Emette il numero della carta Serial.println("Numerocarta:"); Serial.print("Dec: "); Serial.print(rfid.serNum,DEC); Serial.print( )", "); Stampa.seriale(rfid.serNum,DEC); Stampa.seriale(", "); Stampa.seriale(rfid.serNum,DEC); Stampa.seriale(", "); Stampa.seriale( rfid.serNum,DEC); Serial.print(", "); Serial.print(rfid.serNum,DEC); Serial.println(" "); Serial.print("Hex: "); Serial.print(rfid .serNum,HEX); Serial.print(", "); Serial.print(rfid.serNum,HEX); Serial.print(", "); Stampa.seriale(rfid.serNum,HEX); Serial.print(", "); Stampa.seriale(rfid.serNum,HEX); Serial.print(", "); Stampa.seriale(rfid.serNum,HEX); Serial.println(" "); ) else ( /* Se questa è già una carta letta, stampa semplicemente il punto */ Serial.print("."); ) ) ) rfid.halt(); )

Lo schizzo viene caricato, il LED di alimentazione sul modulo si accende, ma il modulo non risponde alla scheda? Non è necessario farsi prendere dal panico o correre a cercare gli esempi di lavoro “corretti”. Molto probabilmente, semplicemente non c'è contatto su uno dei pin: i fori sulla scheda sono leggermente più grandi dello spessore del ponticello, quindi vale la pena provare a riorganizzarli. Il LED sulla scheda non è acceso? Prova a cambiare il ponticello che porta a 3,3 V e assicurati che sia collegato a 3,3 V sulla scheda; fornire alimentazione a 5 V può facilmente uccidere la scheda.

Diciamo che per te funziona tutto. Quindi, leggendo i tag RFID sul monitor porta seriale vedremo quanto segue:

Qui ho letto 3 tag diversi e, come puoi vedere, li ha letti tutti e 3 con successo.

Esempio n.2: lettura dei dati da una carta

Consideriamo un'opzione più sofisticata: leggerà non solo il numero della carta, ma anche tutti i dati disponibili per la lettura. Questa volta prendiamo un esempio dalla libreria MFRC522 - DumpInfo.

#include #include #define RST_PIN 9 // #define SS_PIN 10 // MFRC522 mfrc522(SS_PIN, RST_PIN); // Crea istanza MFRC522 void setup() ( Serial.begin(9600); // Inizializza il monitor della porta seriale while (!Serial); // Non fare nulla finché non è aperto (per Arduino sul chip ATMEGA32U4) SPI.begin( ) ; // Inizializza il bus SPI mfrc522.PCD_Init(); // Inizializza il modulo RFID ShowReaderDetails(); // Visualizza i dati sul modulo MFRC522 Serial.println(F("Scansiona PICC per vedere UID, tipo e blocchi dati ..." )); ) void loop() ( // Alla ricerca nuova mappa if (! mfrc522.PICC_IsNewCardPresent()) ( return; ) // Seleziona una delle carte if (! mfrc522.PICC_ReadCardSerial()) ( return; ) // Emette i dati dalla carta mfrc522.PICC_DumpToSerial(&(mfrc522.uid) ); ) void ShowReaderDetails() ( // Ottiene il numero di versione del modulo byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg); Serial.print(F("MFRC522 Versione software: 0x")); Serial.print(v, HEX); if (v == 0x91) Serial.print(F(" = v1.0")); else if (v == 0x92) Serial.print(F(" = v2.0")); else Serial.print( F (" (sconosciuto)")); Serial.println(""); // Quando riceviamo 0x00 o 0xFF, la trasmissione dei dati viene interrotta se ((v == 0x00) || (v == 0xFF)) ( Serial .println( F("ATTENZIONE: errore di comunicazione, l'MFRC522 è collegato correttamente?")); ) )

Se l'esempio precedente ha funzionato senza errori, anche questo non dovrebbe essere un problema. Tuttavia, l'abbonamento della metropolitana, che nell'esempio precedente forniva il numero della carta senza problemi, in questo caso ha un tipo di dati non rilevabile e il modulo non è riuscito a leggere altro che il numero della carta.

Di conseguenza, dopo aver letto i dati dalla scheda, otteniamo il suo tipo, identificatore e dati da 16 settori di memoria. Va notato che le carte standard MIFARE 1K sono costituite da 16 settori, ogni settore è composto da 4 blocchi e ogni blocco contiene 16 byte di dati.

Esempio n. 3: scrittura di un nuovo identificatore sulla carta

In questo esempio, esamineremo la modifica dell'identificatore della carta (UID). È importante sapere che non tutte le carte supportano il cambio dell'ID. La carta può essere riscrivibile, ma ciò significa solo che i dati sono riscrivibili. Sfortunatamente, le carte che avevo tra le mani non supportavano la riscrittura dell'UID, ma fornirò qui il codice sketch per ogni evenienza.

#include #include /* Imposta un nuovo UID qui */ #define NEW_UID (0xDE, 0xAD, 0xBE, 0xEF) #define SS_PIN 10 #define RST_PIN 9 MFRC522 mfrc522(SS_PIN, RST_PIN); MFRC522::Chiave MIFARE_Key; void setup() ( Serial.begin(9600); while (!Serial); SPI.begin(); mfrc522.PCD_Init(); Serial.println(F("Attenzione: questo esempio sovrascrive l'UID della scheda UID modificabile, usare con cura!")); for (byte i = 0; i< 6; i++) { key.keyByte[i] = 0xFF; } } void loop() { if (! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial()) { delay(50); return; } // Считываем текущий UID Serial.print(F("Card UID:")); for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); } Serial.println(); // Записываем новый UID byte newUid = NEW_UID; if (mfrc522.MIFARE_SetUid(newUid, (byte)4, true)) { Serial.println(F("Wrote new UID to card.")); } // Halt PICC and re-select it so DumpToSerial doesn"t get confused mfrc522.PICC_HaltA(); if (! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial()) { return; } // Считываем данные с карты Serial.println(F("New UID and contents:")); mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); delay(2000); }

Esempio n. 4: scrittura di dati su una scheda

Ecco finalmente quello che stiamo facendo da tanto tempo: registrare i dati sulla scheda. La parte più bella del lavorare con un modulo è la possibilità di farne già una copia mappa esistente, per aggiungere o cambiare qualcosa, questo è molto più interessante della semplice lettura.

Cambiamo uno dei blocchi dati sulla mappa:

#include #include #define RST_PIN 9 #define SS_PIN 10 MFRC522 mfrc522(SS_PIN, RST_PIN); MFRC522::Chiave MIFARE_Key; void setup() ( Serial.begin(9600); while (!Serial); SPI.begin(); mfrc522.PCD_Init(); // Prepara la chiave // ​​usa la chiave FFFFFFFFFFFFh che è lo standard per carte vergini for (byte i = 0; i< 6; i++) { key.keyByte[i] = 0xFF; } Serial.println(F("Scan a MIFARE Classic PICC to demonstrate read and write.")); Serial.print(F("Using key (for A and B):")); dump_byte_array(key.keyByte, MFRC522::MF_KEY_SIZE); Serial.println(); Serial.println(F("BEWARE: Data will be written to the PICC, in sector #1")); } void loop() { // Ждем новую карту if (! mfrc522.PICC_IsNewCardPresent()) return; // Выбираем одну из карт if (! mfrc522.PICC_ReadCardSerial()) return; // Показываем подробности карты Serial.print(F("Card UID:")); dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); Serial.println(); Serial.print(F("PICC type: ")); byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); Serial.println(mfrc522.PICC_GetTypeName(piccType)); // Проверяем совместимость if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI && piccType != MFRC522::PICC_TYPE_MIFARE_1K && piccType != MFRC522::PICC_TYPE_MIFARE_4K) { Serial.println(F("This sample only works with MIFARE Classic cards.")); return; } // В этом примере мы используем первый сектор данных карты, блок 4 byte sector = 1; byte blockAddr = 4; byte dataBlock = { // Данные, которые мы запишем на карту 0x01, 0x02, 0x03, 0x04, // 1, 2, 3, 4, 0x05, 0x06, 0x07, 0x08, // 5, 6, 7, 8, 0x08, 0x09, 0xff, 0x0b, // 9, 10, 255, 12, 0x0c, 0x0d, 0x0e, 0x0f // 13, 14, 15, 16 }; byte trailerBlock = 7; byte status; byte buffer; byte size = sizeof(buffer); // Аутентификация Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Показываем текущие данные сектора Serial.println(F("Current data in sector:")); mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector); Serial.println(); // Читаем данные из блока Serial.print(F("Reading data from block ")); Serial.print(blockAddr); Serial.println(F(" ...")); status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Read() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":")); dump_byte_array(buffer, 16); Serial.println(); Serial.println(); // Аутентификация Serial.println(F("Authenticating again using key B...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Записываем данные в блок Serial.print(F("Writing data into block ")); Serial.print(blockAddr); Serial.println(F(" ...")); dump_byte_array(dataBlock, 16); Serial.println(); status = mfrc522.MIFARE_Write(blockAddr, dataBlock, 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.println(); // Читаем данные снова, чтобы проверить, что запись прошла успешно Serial.print(F("Reading data from block ")); Serial.print(blockAddr); Serial.println(F(" ...")); status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Read() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":")); dump_byte_array(buffer, 16); Serial.println(); Serial.println(F("Checking result...")); byte count = 0; for (byte i = 0; i < 16; i++) { if (buffer[i] == dataBlock[i]) count++; } Serial.print(F("Number of bytes that match = ")); Serial.println(count); if (count == 16) { Serial.println(F("Success:-)")); } else { Serial.println(F("Failure, no match:-(")); Serial.println(F(" perhaps the write didn"t work properly...")); } Serial.println(); // Выводим данные Serial.println(F("Current data in sector:")); mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector); Serial.println(); mfrc522.PICC_HaltA(); mfrc522.PCD_StopCrypto1(); } void dump_byte_array(byte *buffer, byte bufferSize) { for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); } }

Di conseguenza, otteniamo una carta con un blocco dati modificato:

Ora, avendo imparato a leggere e scrivere blocchi di dati di carte, puoi sperimentare i tag che molto probabilmente hai: abbonamenti, abbonamenti trasporto pubblico. Prova a leggere e scrivere i dati di queste carte, un paio di passaggi duplicati non fanno mai male, vero?)

Questo è tutto, iscriviti e segui le pubblicazioni. La prossima volta ti dirò e ti mostrerò come utilizzare uno standard visualizzazione dei caratteri 1602 aggiungono caratteri personalizzati, essenzialmente aggiungendo grafica al display.

La lezione di oggi riguarda come utilizzare un lettore RFID con Arduino per creare un semplice sistema di chiusura, in parole semplici- Blocco RFID.

L'RFID (inglese Radio Frequency IDentification, identificazione a radiofrequenza) è un metodo di identificazione automatica di oggetti in cui i dati memorizzati nei cosiddetti transponder, o tag RFID, vengono letti o scritti utilizzando segnali radio. Qualsiasi sistema RFID è costituito da un dispositivo di lettura (lettore, lettore o interrogatore) e da un transponder (noto anche come tag RFID, a volte viene utilizzato anche il termine tag RFID).

Questo tutorial utilizzerà un tag RFID con Arduino. Il dispositivo legge l'identificatore univoco (UID) di ciascun tag RFID che posizioniamo accanto al lettore e lo visualizza sul display OLED. Se l'UID del tag è valore predefinito, che è memorizzato nella memoria di Arduino, allora vedremo il messaggio “Unlocked” sul display. Se l'ID univoco non è uguale ad un valore predefinito, il messaggio "Sbloccato" non apparirà - vedi foto sotto.

Il castello è chiuso

La serratura è aperta

Parti necessarie per creare questo progetto:

• Lettore RFID RC522
• Display OLED
• Tagliere per il pane
• Fili

Dettagli aggiuntivi:

• Batteria (powerbank)

Il costo totale dei componenti del progetto è stato di circa $ 15.

Passaggio 2: Lettore RFID RC522

In ciascun Etichetta RFID C'è un piccolo chip (carta bianca nella foto). Se accendi una torcia su questa carta RFID, puoi vedere il piccolo chip e la bobina che lo circonda. Questo chip non ha una batteria per generare energia. Riceve alimentazione dal lettore in modalità wireless utilizzando questo bobina di grandi dimensioni. È possibile leggere una tessera RFID come questa fino a 20 mm di distanza.

Lo stesso chip esiste anche nei tag portachiavi RFID.

Ogni tag RFID ha un numero univoco che lo identifica. Questo è l'UID visualizzato sul display OLED. Ad eccezione di questo UID, ogni tag può memorizzare dati. Questo tipo di scheda può memorizzare fino a 1 mila dati. Impressionante, non è vero? Questa funzione non verrà utilizzata oggi. Oggi ciò che interessa è identificare una carta specifica tramite il suo UID. Il costo del lettore RFID e di queste due carte RFID è di circa 4 dollari.

Passaggio 3: display OLED

La lezione utilizza un monitor OLED I2C 128x64 da 0,96".

Questo è molto buona visualizzazione da utilizzare con Arduino. Questo Display OLED e questo significa che l'ha fatto basso consumo energetico. Il consumo energetico di questo display è di circa 10-20 mA e dipende dal numero di pixel.

Il display ha una risoluzione di 128 x 64 pixel ed è di dimensioni ridotte. Sono disponibili due opzioni di visualizzazione. Uno di questi è monocromatico e l'altro, come quello utilizzato nella lezione, può visualizzare due colori: giallo e blu. Parte in alto lo schermo può essere solo giallo e Parte inferiore- blu.

Questo display OLED è molto luminoso e ha una libreria fantastica e molto carina che Adafruit ha sviluppato per questo display. Oltre a ciò, il display utilizza un'interfaccia I2C, quindi la connessione ad Arduino è incredibilmente semplice.

Devi solo collegare due fili tranne Vcc e GND. Se non conosci Arduino e desideri utilizzare un display semplice ed economico nel tuo progetto, inizia da qui.

Passaggio 4: collegamento di tutte le parti