Come programmare una scheda RFID per i tuoi progetti
I tag RFID sono piccoli chip riscrivibili in grado di memorizzare piccole quantità di dati come nomi, indirizzi, informazioni sul prodotto e altro ancora. Possono assumere la forma di portachiavi e carte, o possono anche essere impiantati in animali domestici o persone. Se vuoi imparare come funzionano o aggiungerli al tuo progetto, un lettore e uno scrittore RFID è un componente economico che puoi usare. Questa guida ti mostrerà come usarne uno per scrivere sul tuo tag RFID.
Come funzionano gli scrittori RFID
I sensori RFID reader/writer utilizzano onde radio a corto raggio e bassa potenza per trasmettere i dati dai tag, in cui i dati sono memorizzati, nel dispositivo elettronico a cui è collegato il sensore. In questo caso, useremo un Arduino come dispositivo aggiungendo un sensore RFID. In particolare, scriveremo alcune informazioni di base su un tag RFID.
Per fare questo, faremo uso di questa libreria per la lettura e la scrittura di tag RFID. Poiché l’utilizzo di tag RFID è un po ‘ più complesso di, ad esempio, l’accensione o lo spegnimento di un LED, ci baseremo su schizzi preesistenti che è possibile integrare nei propri progetti. Le funzioni pre-scritte fornite da questi schizzi ti permetteranno di integrarle più facilmente negli altri tuoi progetti.
Per utilizzare la libreria, prima scaricare il .file zip dalla pagina Github sopra. Quindi, apri il tuo IDE Arduino, vai a Sketch > Includi Libreria > Aggiungi .ZIP Library choose e scegli la libreria che hai appena scaricato. Non solo questo renderà possibile includere la libreria RFID nei tuoi schizzi, ma otterrai anche una raccolta di schizzi di esempio, di cui avremo bisogno in seguito.
Cosa ti serve
Per questo progetto, scriveremo solo su un tag RFID. Tuttavia, tenere a mente come andiamo attraverso la guida come è possibile utilizzare questo per estendere i vostri altri progetti. Forse è possibile attivare un blocco per sbloccare quando si mostra al lettore un tag con i dati corretti su di esso, per esempio. Per questo progetto di base, però, ecco cosa ti serve:
| Arduino |  |
| sensore RFID (preferibilmente un MFRC-522) |  |
| i tag RFID |  |
| Breadboard & cablaggio |  |
| IDE di Arduino |  |
| Cavo USB |  |
Dal momento che i chip RFID sono molto piccole, il tag può venire in quasi qualsiasi forma. Due dei tipi più comuni di chip RFID-spesso in arrivo in kit o con sensori – sono piccoli portachiavi rotondi o carte piatte delle dimensioni di una carta di credito. Detto questo, qualunque tag tu abbia dovrebbe funzionare.
Il codice
Se hai installato la libreria come indicato sopra, il seguente schizzo dovrebbe essere disponibile nel tuo libro di esempio sotto File > Esempi > MFRC522 > rfid_write_personal_data. Selezionalo nel tuo libro di esempio o copia il codice qui sotto:
/*
* Scrivere i dati personali di una scheda RFID MIFARE utilizzando un lettore RFID-RC522
* Utilizza MFRC522-Library per utilizzare ARDUINO RFID MODULE KIT 13.56 MHZ CON TAG SPI W E R DI COOQROBOT.
* ——————————
* MFRC522 Arduino Arduino Arduino Arduino Arduino
* Lettore/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
* Segnale Pin Pin Pin Pin Pin Pin
* ——————————
* PRIMA/Reset PRIMI 9 5 D9 RESET/ICSP-5 PRIMA
* SPI SS SDA(SS) 10 53 D10 10 10
* SPI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
* SPI MISO 12 / ICSP-1 50 D12 ICSP-1 14
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
*
* Hardware richiesto:
* Arduino
* PCD (Proximity Coupling Device): NXP MFRC522 Contactless Reader IC
* PICC (Proximity Integrated Circuit Card): una scheda o un tag utilizzando l’interfaccia ISO 14443A, ad esempio Mifare o NTAG203.
* Il lettore può essere trovato su eBay per circa 5 dollari. Cerca “mf-rc522” su ebay.com.
*/
#include
#include
#define RST_PIN 9 // Configurabile, vedi layout pin tipico sopra
#define SS_PIN 10 / / Configurabile, vedi layout pin tipico sopra
MFRC522 mfrc522 (SS_PIN, RST_PIN); // Crea istanza MFRC522
void setup () {
Seriale.begin (9600); / / Inizializzare le comunicazioni seriali con il PC
SPI.inizia (); / / Init bus SPI
mfrc522.PCD_Init (); / / Scheda Init MFRC522
Seriale.println (F (“Scrivere dati personali su un MIFARE PICC “));
}
ciclo vuoto() {
// Preparare chiave – tutti i tasti sono impostati su FFFFFFFFFFFFh alla consegna del chip dalla fabbrica.
MFRC522:: MIFARE_Key chiave;
per (byte i = 0; i < 6; i++) chiave.keyByte = 0xFF;
/ / Ripristinare il ciclo se nessuna nuova scheda presente sul sensore / lettore. Ciò salva l’intero processo quando è inattivo.
se ( ! mfrc522.PICC_IsNewCardPresent ()) {
ritorno;
}
// Selezionare una delle carte
se (! mfrc522.PICC_ReadCardSerial ()) {
ritorno;
}
Seriale.stampa (F (“Carta UID:”)); //Dump UID
per (byte i = 0; i < mfrc522.uid.dimensione; i++) {
Seriale.stampa(mfrc522.uid.uidByte < 0x10 ? “0” : “”);
Seriale.stampa(mfrc522.uid.uidByte, HEX);
}
Seriale.stampa (F (“PICC type:”)); / / Dump PICC type
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType (mfrc522.uid.sak);
Seriale.println(mfrc522.PICC_GetTypeName(piccType));
buffer di byte;
blocco di byte;
MFRC522::stato StatusCode;
byte len;
Seriale.setTimeout(20000L); / / attendere fino a 20 secondi per l’input da seriale
// Chiedere dati personali: Cognome
Seriale.println (F (“Nome famiglia tipo, che termina con#”));
len = Seriale.readBytesUntil (‘# ‘, (char *) buffer, 30); / / leggi il nome della famiglia da seriale
per (byte i = len; i< 30; i++) buffer = ‘ ‘; // pad con spazi
block = 1;
//Seriale.println (F (“Autenticazione tramite la chiave A””));
status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK) {
Serial.print(F(“PCD_Authenticate() failed: “));
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}
else Serial.println(F(“PCD_Authenticate() success: “));
// Write block
status = mfrc522.MIFARE_Write(block, buffer, 16);
if (status != MFRC522::STATUS_OK) {
Serial.print(F(“MIFARE_Write() failed: “));
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}
else Serial.println (F (“MIFARE_Write () successo: “));
blocco = 2;
//Seriale.println (F (“Autenticazione tramite la chiave A””));
status = mfrc522.PCD_Authenticate(MFRC522:: PICC_CMD_MF_AUTH_KEY_A, blocco, & chiave, & (mfrc522.uid));
if (stato != MFRC522:: STATUS_OK) {
Seriale.print (F (“PCD_Authenticate () failed:”));
Seriale.println(mfrc522.GetStatusCodeName (stato));
ritorno;
}
// Scrivi blocco
stato = mfrc522.MIFARE_Write (blocco, &buffer, 16);
if (stato != MFRC522:: STATUS_OK) {
Seriale.stampa (F (“MIFARE_Write () non riuscita:”));
Seriale.println(mfrc522.GetStatusCodeName (stato));
ritorno;
}
altro seriale.println (F (“MIFARE_Write () successo: “));
// Chiedi dati personali: Nome
Seriale.println (F (“Digitare il nome, che termina con#”));
len = Seriale.readBytesUntil (‘# ‘, (char *) buffer, 20); / / leggi nome da seriale
per (byte i = len; i< 20; i++) buffer = ‘ ‘; // pad con spazi
block = 4;
//Seriale.println (F (“Autenticazione tramite la chiave A””));
status = mfrc522.PCD_Authenticate(MFRC522:: PICC_CMD_MF_AUTH_KEY_A, blocco, & chiave, & (mfrc522.uid));
se (stato != MFRC522:: STATUS_OK) {
Seriale.print (F (“PCD_Authenticate () failed:”));
Seriale.println(mfrc522.GetStatusCodeName (stato));
ritorno;
}
// Scrivi blocco
stato = mfrc522.MIFARE_Write (blocco, buffer, 16);
if (stato != MFRC522:: STATUS_OK) {
Seriale.stampa (F (“MIFARE_Write () non riuscita:”));
Seriale.println(mfrc522.GetStatusCodeName (stato));
ritorno;
}
altro seriale.println (F (“MIFARE_Write () successo: “));
blocco = 5;
//Seriale.println (F (“Autenticazione tramite la chiave A””));
status = mfrc522.PCD_Authenticate(MFRC522:: PICC_CMD_MF_AUTH_KEY_A, blocco, & chiave, & (mfrc522.uid));
if (stato != MFRC522:: STATUS_OK) {
Seriale.print (F (“PCD_Authenticate () failed:”));
Seriale.println(mfrc522.GetStatusCodeName (stato));
ritorno;
}
// Scrivi blocco
stato = mfrc522.MIFARE_Write (blocco, &buffer, 16);
if (stato != MFRC522:: STATUS_OK) {
Seriale.stampa (F (“MIFARE_Write () non riuscita:”));
Seriale.println(mfrc522.GetStatusCodeName (stato));
ritorno;
}
altro seriale.println (F (“MIFARE_Write () successo: “));
Seriale.println(” “);
mfrc522.PICC_HaltA (); / / Halt PICC
mfrc522.PCD_StopCrypto1 (); / / Interrompere la crittografia su PCD
}
Carica questo codice e (dopo aver cablato il tuo progetto come descritto di seguito) puoi immediatamente iniziare a scrivere dati sui tuoi tag RFID.
Uno dei vantaggi dell’utilizzo di librerie come questa è che puoi trovare porzioni di codice già scritte, quindi non devi reinventare la ruota per ogni progetto. Questa volta, non abbiamo intenzione di passare attraverso il codice riga per riga. Invece, parliamo un po ‘ di più su ciò che fa il codice.
I dati nei tag RFID sono memorizzati in sezioni chiamate settori, che sono ulteriormente suddivisi in blocchi. Ogni blocco può contenere alcuni byte di dati. La quantità dipende dal tag specifico, ma un tag passivo comune 1K (ovvero un tag in grado di memorizzare 1 kilobyte di dati) potrebbe, ad esempio, avere 16 settori, ciascuno contenente 4 blocchi, con ogni blocco in grado di memorizzare fino a 16 byte di dati.
Questo schizzo memorizzerà solo il tuo nome e cognome, quindi ha bisogno solo di un settore, ma diffonderà i dati su più blocchi, poiché i tuoi nomi potrebbero occupare più dati di quelli che possono essere inseriti in un singolo blocco (e per comodità organizzativa).
Quando esegui lo script, ti verrà chiesto di fornire il tuo nome di famiglia, che verrà poi scritto sui blocchi sul tuo tag RFID. Successivamente, riceverai un prompt per scrivere il tuo nome, che verrà scritto su diversi blocchi. Per ulteriori informazioni su come sono organizzati i blocchi RFID e su come affrontarli, consulta questa guida.
Il cablaggio
Il cablaggio per il tuo lettore RFID specifico dipenderà dal modello che ottieni, poiché molte iterazioni diverse hanno i pin in un ordine diverso. Fortunatamente, il codice di esempio che abbiamo incluso sopra elenca quali pin dovrebbero andare dove a seconda della scheda che stai utilizzando. Seguire questa guida per le specifiche.
Ad esempio, se si stesse utilizzando un Arduino Uno e un sensore MFRC-522, si dovrebbe fare quanto segue:
● Collegare il PRIMO al pin 9
● Collegare SDA (o SS) al pin 10
● Collegare MOSI al pin 11
● Collegare il MISO al pin 12
● Collegare SCK al pin 13
● Collegare VCC 5V
● Collegare a GND GND
Ma, di nuovo, controllare che consigli si utilizza per assicurarsi che sia collegato correttamente. Una volta che la scheda è collegata, accendere il Arduino mentre è collegato tramite USB al computer. Quindi, è possibile premere una scheda RFID o un portachiavi sul lettore. Tienilo lì mentre inserisci i dati attraverso il monitor seriale.
La libreria MFRC522 include anche uno schizzo integrato per la lettura dei dati RFID dopo averlo scritto. Ora che sai come scrivere i dati, prova a caricare lo schizzo e ad usarlo per leggere il tag su cui hai scritto.