Hur man använder Arduino och RFID med RC522-modulen

Om du någonsin har gått igenom en självutcheckning i en mataffär och sett hur alla dina varor automatiskt visas på skärmen när du placerar dem på en bricka , har du redan sett RFID i aktion. Det är inte magi eller teknologisk telepati: det är ett radiofrekvensbaserat system som låter dig identifiera objekt utan direktkontakt, och du kan kopiera det hemma med en enkel Arduino och en billig läsare som RC522.

I den här guiden lär du dig steg för steg hur du använder Arduino och en RC522 RFID-läsare för att läsa och skriva taggar, förstår exakt vad RFID är, vilka typer av system som finns, hur passiva kort drivs, hur minnet på ett MIFARE Classic 1K-kort är organiserat och hur man bygger verkliga projekt som ett åtkomstkontrollsystem eller ett laddningsbart transitkort. Gör dig bekväm, för vi kommer att fördjupa oss i ämnet grundligt, men på ett tydligt och lättillgängligt sätt.

Vad är RFID-teknik och hur fungerar den?

Radiofrekvensidentifiering, eller RFID, är ett system som gör det möjligt att känna igen objekt med hjälp av en unik identifierare som sänds via radio. Denna identifierare kallas vanligtvis UID (Unique ID) och kan betraktas som taggens ID. Hela systemet består av två huvudelement: RFID-taggen (eller transpondern) och RFID-läsaren (sändtagaren).

RFID-taggar finns i många olika format: kreditkortsliknande plastkort, nyckelringar, självhäftande klistermärken som fästs på produkter för att förhindra stöld, och till och med chips som implanteras under huden på djur för identifiering. Internt delar de alla samma komponenter: en antenn och ett litet chip som lagrar information och kommunicerar med läsaren.

Det finns skrivskyddade taggar, vars UID är fabriksprogrammerat och inte kan ändras, och läs-/skrivtaggar, som en lämplig läsare, såsom RC522-modulen, både kan läsa och skriva data till . Detta möjliggör tillämpningar som laddningsbara transitkort, åtkomstkontrollsystem med förbetalda saldon, tid- och närvarosystem med mera.

Å andra sidan har vi RFID-läsaren eller sändtagaren. Denna enhet tar inte bara emot data utan avger även ett radiofrekvent elektromagnetiskt fält . Detta fält är nyckeln till att förstå hur passiva taggar drivs och hur information utbyts mellan kortet och läsaren.

Strömförsörjning och funktionsprincip för RFID-taggar

En mycket vanlig fråga är: om RFID-klistermärkena på mataffärsprodukter eller passerkort inte har batterier, var får de energin ifrån? Det viktiga är att många av dessa taggar är passiva och drivs av elektromagnetisk induktion från det fält som genereras av läsaren.

När du för en passiv tagg nära en läsare, kommer dess antenn att hamna i det elektromagnetiska fält som genereras av modulen (till exempel vid 13,56 MHz för RC522). Detta fält inducerar en ström i taggens antenn, som används för att tillfälligt driva det interna chipet . När det är "vaket" modulerar chipet signalen det skickar tillbaka till läsaren (detta kallas bakåtspridning), vilket kodar UID och, om tillämpligt, annan data som lagras i minnet.

Till skillnad från tekniker som infraröd strålning krävs ingen direkt siktlinje mellan taggen och läsaren : radiofrekvenser kan penetrera vissa material, även om deras beteende beror på frekvensen, närvaron av metall, vatten etc. Läsaren fångar upp den bakåtspridda signalen, tolkar den och skickar sedan data till en mikrokontroller (som Arduino, ESP8266 eller ESP32) eller en dator.

Typer av RFID-system enligt frekvens

Radiofrekvensspektrumet är mycket brett, och radiovågor beter sig inte likadant på alla frekvenser . Därför används olika band i RFID beroende på tillämpning. Läsaren och taggen måste vara utformade för att fungera på samma frekvens, precis som en radio måste ställa in sig på rätt station.

Generellt sett kan vi gruppera RFID-system i tre huvudkategorier beroende på vilket band de använder:

• Lågfrekvens (LF)runt 125-134 kHz.
• Högfrekvens (HF): runt 13,56 MHz, vilket inkluderar tekniker som MIFARE och NFC.
• Ultrahög frekvens (UHF)mellan cirka 433 MHz och 860-960 MHz.

Lågfrekventa (LF) RFID-system

Lågfrekventa RFID-system har en relativt lång våglängd, vilket gör att de bättre kan penetrera tunna material och föremål med hög vattenhalt , såsom frukt eller drycker. De fungerar också relativt bra nära tunna metaller.

Denna fördel har dock betydande begränsningar: den typiska räckvidden är bara några centimeter, och dataöverföringshastigheten är låg, vilket resulterar i minskad minneskapacitet och högre kostnader för taggar . Dessa system används ofta för enkel åtkomstkontroll, äldre närhetsnycklar och djurmärkning.

Högfrekventa (HF) RFID- och NFC-system

Högfrekvensbandet, vid 13,56 MHz, är förmodligen det mest populära på "tillverkare"- och gör-det-själv-projektnivå, eftersom det är där MIFARE-kort och NFC-teknik (Near-Field Communication) finns , vilket många mobiltelefoner använder för kontaktlösa betalningar.

HF-system fungerar bra nära metall och i närvaro av måttliga till höga vattennivåer, och erbjuder vanligtvis en räckvidd på några centimeter upp till ungefär en meter under ideala förhållanden. Datahastigheterna är fortfarande blygsamma men tillräckliga för identifiering, åtkomst och små dataöverföringsapplikationer. Många globala standarder är baserade på HF, vilket underlättar interoperabilitet mellan utrustning och kort.

Ultrahögfrekventa (UHF) RFID-system

I den motsatta änden av spektrumet finns UHF-system, som kan nå avstånd från några centimeter till över 20 meter. De är idealiska när många taggar behöver läsas snabbt och på avstånd , till exempel för lagerhantering i lager, räkning av personer vid evenemang eller tidtagning av idrottare när de korsar mållinjen i lopp.

Nackdelen är att signalen, med sin kortare våglängd, dämpas mer och penetrerar metall och vatten mindre effektivt . Trots detta används de ofta i vägtullssystem, parkeringstillträdeskontroll och storskalig logistikspårning.

RC522 RFID-modulen: funktioner och stift

För Arduino-projekt är en av de mest populära läsarna RC522, baserad på NXP MFRC522-chippet. Det är en mycket prisvärd och flitigt använd modul som arbetar med hög frekvens (13,56 MHz) med MIFARE-kort och möjliggör både läsning och skrivning till kompatibla taggar.

Den säljs vanligtvis i ett kit som innehåller själva läsaren, ett kreditkort och en RFID-nyckelbricka. Dessa kort är vanligtvis 1K- eller 4K-MIFARE Classic-kort, en extremt populär standard inom transport, åtkomstkontroll och lågkostnadslösningar. RC522 genererar ett HF-elektromagnetiskt fält, och i praktiken är dess användbara räckvidd cirka 3–5 cm, även om det teoretiskt kan nå något längre.

När det gäller kommunikation med mikrokontrollern är RC522 huvudsakligen integrerad via SPI (Serial Peripheral Interface) och stöder hastigheter upp till 10 Mbps. Den stöder även I2C och UART, även om SPI används i de flesta Arduino-projekt på grund av dess högre hastighet och enkelhet i detta sammanhang.

Elektriskt sett drivs modulen av en matningsspänning mellan 2,5 V och 3,3 V. Kortet har vanligtvis en tydligt markerad VCC-pin för anslutning till 3,3 V. Spän inte direkt med 5 V , annars riskerar du att skada det. På den positiva sidan är logiska nivåer generellt toleranta mot 5 V, så den kan anslutas till Arduino UNO digitala pinnar utan nivåomvandlare för grundläggande tester, även om det i en professionell design är lämpligt att anpassa nivåerna.

Fästa RC522-modulen

En typisk RC522 har 8 anslutningsstift till mikrokontrollern:

• VCC: strömförsörjning, mellan 2,5 V och 3,3 V.
• RSTåterställningsstift; möjliggör avstängning och omstart av modulen genom att ställa in nivån till LÅG/HÖG.
• GNDjordens massa eller referens.
• IRQ: avbrottsstift som kan varna mikrokontrollern när en tagg kommer in i läsarfältet.
• MISO / SCL / TXmultifunktionsstift; såsom MISO i SPI, såsom SCL i I2C, eller såsom TX i UART.
• SLÅ DANK: utgångsdatalinje från master till slav i SPI.
• SCKSPI-gränssnittsklocka.
• SS / SDA / RXslavvalspin i SPI, SDA i I2C eller RX i UART.

På Arduino UNO och andra ATmega328P-baserade kort är SPI-pinnarna redan definierade av hårdvaran, så det typiska kopplingsschemat för att använda SPI är:

• VCC → 3,3 V från Arduino.
• GND → Arduino GND.
• SCK → stift 13 på UNO/Nano.
• SLÅ DANK → stift 11 på UNO/Nano.
• MISO → stift 12 på UNO/Nano.
• SS (SDA) → pin 10 (eller den du väljer som SS, men du måste ange det i koden).
• RST → till exempel, Arduino-pin 9.
• IRQ → Valfritt, kan lämnas opererad om inget avbrott används.

På kort som Arduino Mega, Leonardo eller Micro kan SPI-linjerna sitta på olika stift eller på ICSP-kontakten, så det är viktigt att kontrollera ekvivalenstabellen i den officiella dokumentationen innan du kopplar in något.

Installera MFRC522-biblioteket och grundläggande taggläsning

Även om MFRC522 kan programmeras från grunden är dess interna kommunikation ganska komplex, så det är vanligt att använda biblioteket som utvecklats av Miguel Balboa , tillgängligt på GitHub och i Arduino IDE:s bibliotekshanterare. Detta bibliotek innehåller alla operationer som krävs för att initiera läsaren, detektera kort, autentisera sektorer och läsa eller skriva block.

För att installera det från Arduino IDE, öppna helt enkelt Bibliotekshanteraren, sök efter "MFRC522" och välj den community-underhållna versionen (GitHub Community) . Du måste också inkludera SPI-biblioteket, som redan ingår i IDE:n.

När det väl är installerat är det typiska flödet i en enkel skiss för att läsa en etiketts UID:

• Inkludera bokhandlar SPI.hy MFRC522.h.
• Definiera RST- och SS-stiften som läsaren ska använda.
• Skapa ett MFRC522-objekt genom att skicka dessa pinnar till det.
• I setup(), initiera seriell, SPI och läsaren med PCD_Init().
• I loop(), använd PICC_ÄrNyttKortNuvarande() för att ta reda på om det finns ett kort i närheten och PICC_LäsKortSeriell() för att läsa dina grundläggande data.
• Åtkomst till UID:t med hjälp av mfrc522.uid.uidByte och till storleken med mfrc522.uid.size.
• Avsluta kommunikationen med skivbolaget genom att ringa PICC_HaltA().

Den här typen av skiss är perfekt för att hämta UID för flera kort eller nyckelringar och utföra snabba tester, till exempel för enkel åtkomstkontroll där endast det lästa UID:t jämförs med en lista över auktoriserade UID:er.

Minnesstruktur i MIFARE Classic 1K-kort

Korten som vanligtvis medföljer RC522 är vanligtvis MIFARE Classic 1K . Dessa kort erbjuder 1 KB minne organiserat hierarkiskt i sektorer och block, med ett ganska märkligt nyckel- och behörighetssystem som bör förstås innan man skriver något.

Det totala minnet är uppdelat i 16 sektorer numrerade från 0 till 15. Varje sektor innehåller 4 block, märkta från 0 till 3 inom den sektorn. Varje block lagrar 16 byte data , det vill säga 16 positioner numrerade från 0 till 15, så varje sektor erbjuder 64 byte.

Inom dessa fyra block per sektor är endast tre avsedda för att lagra användardata: block 0, 1 och 2 i varje sektor (förutom sektor 0, som har speciella egenskaper). Det sista blocket i varje sektor, block 3, kallas trailerblocket . Det lagrar krypteringsnycklarna och åtkomstbitarna som styr vilka operationer som är tillåtna i den sektorn.

I trailern är de 16 bytena uppdelade enligt följande:

• Nyckel A: 1 024 byte.
• Åtkomstvillkor: 3 byte som definierar läs-/skrivbehörigheter, autentisering och nyckelsynlighet.
• Oanvänd byte (U)1 byte som inte används.
• Nyckel B: 1 024 byte.

Korten som levereras från fabriken med modulerna har vanligtvis nyckel A och nyckel B initialiserade till FF FF FF FF FF FF , vilket är extremt osäkert, eftersom vem som helst som känner till standarden kan autentisera och ändra kortets innehåll. En relativt vanlig praxis i gör-det-själv-projekt är att använda samma nycklar i alla sektorer, även om det för verklig säkerhet vore bättre att diversifiera.

Dessutom är block 0 i sektor 0 speciellt: det lagrar kortets UID (vanligtvis 4 byte i dessa MIFARE Classic-kort) och tillverkardata. Detta block anses i praktiken vara skrivskyddat; ett försök att ändra det kan oåterkalleligt skada kortet.

Ändra tangenterna Tangent A och Tangent B i en sektor

Om du vill använda ett MIFARE-kort i ett Arduino- och RC522-projekt på något meningsfullt sätt, bör du först ändra standardnycklarna . Detta förhindrar att någon med en läsare och standardbiblioteket manipulerar ditt kort obehörigt.

Grundidén för att uppdatera nycklarna för en specifik sektor (till exempel sektor 15) är följande:

• Definiera de aktuella nycklarna i koden (fabriksinställningarna, om de inte har ändrats).
• Definiera de nya nyckelorden Key A och Key B som du vill använda i den sektorn.
• Beräkna släpvagnsblocknumret för den sektorn, vilket är sektor * 4 + 3 (för sektor 15, block 63).
• Autentisera först med aktuell nyckel A med hjälp av PCD_Authenticate() om släpvagnsblocket.
• Läs trailerblocket med MIFARE_Läs() för att få ditt innehåll.
• Ändra byten som motsvarar de nya nycklarna i en buffert.
• Autentisera igen om det behövs (till exempel med nyckel B).
• Skriv det uppdaterade trailerblocket med MIFARE_Write().

Under denna process är det avgörande att inte flytta kortet från läsaren förrän operationen är klar , eftersom en avbruten skrivning till trailerblocket kan göra sektorn oåtkomlig. När nycklarna har ändrats måste du också uppdatera Arduino-koden för att använda dessa nya nycklar i framtida operationer på den sektorn.

Läsa och skriva block: simulera ett transportkort

En mycket illustrativ tillämpning av läsning och skrivning med MIFARE Classic är att simulera beteendet hos ett laddningsbart kollektivtrafikkort . Idén är enkel: kortet lagrar ett antal resor i ett specifikt block, och systemet låter dig ladda resor (ladda) eller använda dem (validering vid ombordstigning på bussen eller spårvagnen).

För detta ändamål skulle sektor 15 kunna reserveras för användardata, till exempel, och ett av dess datablock (till exempel block 60) skulle kunna användas för att lagra trippräknaren. Antalet tillgängliga tripp lagras i byte 0 i blocket. De återstående bytena i blocket skulle kunna användas för annan data eller helt enkelt lämnas på noll.

Det typiska kodflödet för omladdningsdelen skulle vara:

• Definiera Nyckel A och nyckel B gällande bestämmelser som skyddar sektorn i fråga (till exempel de vi ändrade i föregående steg).
• Definiera sektornumret, datablocket (60) och trailerblocket (63).
• Deklarera en 16-byte array (blockData) där den första byten representerar antalet resor.
• Varje gång ett kort förs nära läsaren, Läs block 60 använder MIFARE_Read() för att hämta de aktuella turerna.
• Lägg till antalet resor som ska laddas (till exempel 10) till det avlästa värdet.
• Uppdatera data. Blockera med det nya antalet resor.
• Autentisera med nyckel A mot motsvarande släpvagnsblock.
• Skriv block 60 med MIFARE_Write().
• Läs igen för att kontrollera att värdet har uppdaterats korrekt.

För reseförbrukningsdelen (validering på bussen) är koden praktiskt taget identisk, men istället för att lägga till subtraheras ett från räknaren. Innan subtraktionen sker kontrolleras om det avlästa värdet är noll: om det inte finns några resor kvar nekas åtkomst och användaren uppmanas att ladda om . Om räknaren är större än noll minskas den, blocket skrivs om och antalet återstående resor visas på skärmen.

I båda fallen är det viktigt att hantera returkoderna för MFRC522-biblioteksfunktionerna korrekt (t.ex. autentiserings- eller skrivfel) och alltid stoppa krypterad kommunikation med PCD_StopCrypto1() och själva kortet med PICC_HaltA() i slutet av varje cykel.

Enkel åtkomstkontroll baserad på UID

Ett annat klassiskt projekt som använder RC522 och Arduino är ett grundläggande åtkomstkontrollsystem där åtkomst beviljas eller nekas baserat på UID för det presenterade kortet. Denna metod använder inte kortet internminne, bara dess unika identifierare, och är därför ganska begränsad i säkerhet, men det fungerar som ett snabbt exempel.

Det typiska tillvägagångssättet är:

• Läs kortets UID med hjälp av de grundläggande biblioteksfunktionerna (PICC_IsNewCardPresent, PICC_ReadCardSerial, etc.).
• Kopiera byte från det lästa UID:t till en tillfällig array (t.ex. ActualUID).
• Definiera i koden flera arrayer med UID:erna för auktoriserade kort (till exempel Användare1, Användare2).
• Skapa en byte array jämförelsefunktion som returnerar sant om båda är identiska.
• Jämför ActualUID med varje auktoriserat UID och, om någon matchning, aktivera en digital utgång, visa meddelandet "Åtkomst beviljad" eller aktivera ett elektriskt lås.
• Om det inte matchar någon av dem, visa "Åtkomst nekad" och håll systemet stängt.

I en verklig miljö är ett sådant system sårbart för taggkloning eftersom många billiga läsare tillåter kopiering eller emulering av UID:er. För att öka säkerheten skulle det vara nödvändigt att använda kortets internminne, anpassade nycklar och eventuellt mer robusta kryptografiska mekanismer än de i MIFARE Classic, vars säkerhet för närvarande ifrågasätts i stor utsträckning. Ändå fungerar det som ett utmärkt pedagogiskt exempel för att lära sig arbetsflödet för kortläsning och integration med fysiska aktuatorer.

Med allt ovanstående har du nu en god förståelse för de grundläggande RFID-koncepten, förstår hur olika frekvensband beter sig, känner till hur ett MIFARE Classic 1K-kort fungerar internt, behärskar den grundläggande anslutningen och användningen av RC522-modulen med Arduino, och har i detalj sett hur man läser och skriver block för att skapa verkliga system som åtkomstkontroll eller transitkort . Härifrån är nästa naturliga steg att kombinera RFID med andra moduler (LCD-skärmar, reläer, Wi-Fi, molndatabaser) och lära dig hur man styr smarta glödlampor för att bygga mer omfattande lösningar som är ännu närmare de professionella system du ser varje dag i butiker, kollektivtrafik och kontaktlösa betalningsenheter.