初始化提交
This commit is contained in:
王立帮
@@ -0,0 +1,537 @@
|
||||
/*
|
||||
--------------------------------------------------------------------------------------------------------------------
|
||||
Example sketch/program showing An Arduino Door Access Control featuring RFID, EEPROM, Relay
|
||||
--------------------------------------------------------------------------------------------------------------------
|
||||
This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
|
||||
This example showing a complete Door Access Control System
|
||||
|
||||
Simple Work Flow (not limited to) :
|
||||
+---------+
|
||||
+----------------------------------->READ TAGS+^------------------------------------------+
|
||||
| +--------------------+ |
|
||||
| | | |
|
||||
| | | |
|
||||
| +----v-----+ +-----v----+ |
|
||||
| |MASTER TAG| |OTHER TAGS| |
|
||||
| +--+-------+ ++-------------+ |
|
||||
| | | | |
|
||||
| | | | |
|
||||
| +-----v---+ +----v----+ +----v------+ |
|
||||
| +------------+READ TAGS+---+ |KNOWN TAG| |UNKNOWN TAG| |
|
||||
| | +-+-------+ | +-----------+ +------------------+ |
|
||||
| | | | | | |
|
||||
| +----v-----+ +----v----+ +--v--------+ +-v----------+ +------v----+ |
|
||||
| |MASTER TAG| |KNOWN TAG| |UNKNOWN TAG| |GRANT ACCESS| |DENY ACCESS| |
|
||||
| +----------+ +---+-----+ +-----+-----+ +-----+------+ +-----+-----+ |
|
||||
| | | | | |
|
||||
| +----+ +----v------+ +--v---+ | +--------------->
|
||||
+-------+EXIT| |DELETE FROM| |ADD TO| | |
|
||||
+----+ | EEPROM | |EEPROM| | |
|
||||
+-----------+ +------+ +-------------------------------+
|
||||
|
||||
|
||||
Use a Master Card which is act as Programmer then you can able to choose card holders who will granted access or not
|
||||
|
||||
* **Easy User Interface**
|
||||
|
||||
Just one RFID tag needed whether Delete or Add Tags. You can choose to use Leds for output or Serial LCD module to inform users.
|
||||
|
||||
* **Stores Information on EEPROM**
|
||||
|
||||
Information stored on non volatile Arduino's EEPROM memory to preserve Users' tag and Master Card. No Information lost
|
||||
if power lost. EEPROM has unlimited Read cycle but roughly 100,000 limited Write cycle.
|
||||
|
||||
* **Security**
|
||||
To keep it simple we are going to use Tag's Unique IDs. It's simple and not hacker proof.
|
||||
|
||||
@license Released into the public domain.
|
||||
|
||||
Typical pin layout used:
|
||||
-----------------------------------------------------------------------------------------
|
||||
MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
Signal Pin Pin Pin Pin Pin Pin
|
||||
-----------------------------------------------------------------------------------------
|
||||
RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
SPI SS SDA(SS) 10 53 D10 10 10
|
||||
SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <EEPROM.h> // We are going to read and write PICC's UIDs from/to EEPROM
|
||||
#include <SPI.h> // RC522 Module uses SPI protocol
|
||||
#include <MFRC522.h> // Library for Mifare RC522 Devices
|
||||
|
||||
/*
|
||||
Instead of a Relay you may want to use a servo. Servos can lock and unlock door locks too
|
||||
Relay will be used by default
|
||||
*/
|
||||
|
||||
// #include <Servo.h>
|
||||
|
||||
/*
|
||||
For visualizing whats going on hardware we need some leds and to control door lock a relay and a wipe button
|
||||
(or some other hardware) Used common anode led,digitalWriting HIGH turns OFF led Mind that if you are going
|
||||
to use common cathode led or just seperate leds, simply comment out #define COMMON_ANODE,
|
||||
*/
|
||||
|
||||
#define COMMON_ANODE
|
||||
|
||||
#ifdef COMMON_ANODE
|
||||
#define LED_ON LOW
|
||||
#define LED_OFF HIGH
|
||||
#else
|
||||
#define LED_ON HIGH
|
||||
#define LED_OFF LOW
|
||||
#endif
|
||||
|
||||
#define redLed 7 // Set Led Pins
|
||||
#define greenLed 6
|
||||
#define blueLed 5
|
||||
|
||||
#define relay 4 // Set Relay Pin
|
||||
#define wipeB 3 // Button pin for WipeMode
|
||||
|
||||
bool programMode = false; // initialize programming mode to false
|
||||
|
||||
uint8_t successRead; // Variable integer to keep if we have Successful Read from Reader
|
||||
|
||||
byte storedCard[4]; // Stores an ID read from EEPROM
|
||||
byte readCard[4]; // Stores scanned ID read from RFID Module
|
||||
byte masterCard[4]; // Stores master card's ID read from EEPROM
|
||||
|
||||
// Create MFRC522 instance.
|
||||
#define SS_PIN 10
|
||||
#define RST_PIN 9
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN);
|
||||
|
||||
///////////////////////////////////////// Setup ///////////////////////////////////
|
||||
void setup() {
|
||||
//Arduino Pin Configuration
|
||||
pinMode(redLed, OUTPUT);
|
||||
pinMode(greenLed, OUTPUT);
|
||||
pinMode(blueLed, OUTPUT);
|
||||
pinMode(wipeB, INPUT_PULLUP); // Enable pin's pull up resistor
|
||||
pinMode(relay, OUTPUT);
|
||||
//Be careful how relay circuit behave on while resetting or power-cycling your Arduino
|
||||
digitalWrite(relay, HIGH); // Make sure door is locked
|
||||
digitalWrite(redLed, LED_OFF); // Make sure led is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure led is off
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure led is off
|
||||
|
||||
//Protocol Configuration
|
||||
Serial.begin(9600); // Initialize serial communications with PC
|
||||
SPI.begin(); // MFRC522 Hardware uses SPI protocol
|
||||
mfrc522.PCD_Init(); // Initialize MFRC522 Hardware
|
||||
|
||||
//If you set Antenna Gain to Max it will increase reading distance
|
||||
//mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max);
|
||||
|
||||
Serial.println(F("Access Control Example v0.1")); // For debugging purposes
|
||||
ShowReaderDetails(); // Show details of PCD - MFRC522 Card Reader details
|
||||
|
||||
//Wipe Code - If the Button (wipeB) Pressed while setup run (powered on) it wipes EEPROM
|
||||
if (digitalRead(wipeB) == LOW) { // when button pressed pin should get low, button connected to ground
|
||||
digitalWrite(redLed, LED_ON); // Red Led stays on to inform user we are going to wipe
|
||||
Serial.println(F("Wipe Button Pressed"));
|
||||
Serial.println(F("You have 10 seconds to Cancel"));
|
||||
Serial.println(F("This will be remove all records and cannot be undone"));
|
||||
bool buttonState = monitorWipeButton(10000); // Give user enough time to cancel operation
|
||||
if (buttonState == true && digitalRead(wipeB) == LOW) { // If button still be pressed, wipe EEPROM
|
||||
Serial.println(F("Starting Wiping EEPROM"));
|
||||
for (uint16_t x = 0; x < EEPROM.length(); x = x + 1) { //Loop end of EEPROM address
|
||||
if (EEPROM.read(x) == 0) { //If EEPROM address 0
|
||||
// do nothing, already clear, go to the next address in order to save time and reduce writes to EEPROM
|
||||
}
|
||||
else {
|
||||
EEPROM.write(x, 0); // if not write 0 to clear, it takes 3.3mS
|
||||
}
|
||||
}
|
||||
Serial.println(F("EEPROM Successfully Wiped"));
|
||||
digitalWrite(redLed, LED_OFF); // visualize a successful wipe
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_ON);
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_OFF);
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_ON);
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_OFF);
|
||||
}
|
||||
else {
|
||||
Serial.println(F("Wiping Cancelled")); // Show some feedback that the wipe button did not pressed for 15 seconds
|
||||
digitalWrite(redLed, LED_OFF);
|
||||
}
|
||||
}
|
||||
// Check if master card defined, if not let user choose a master card
|
||||
// This also useful to just redefine the Master Card
|
||||
// You can keep other EEPROM records just write other than 143 to EEPROM address 1
|
||||
// EEPROM address 1 should hold magical number which is '143'
|
||||
if (EEPROM.read(1) != 143) {
|
||||
Serial.println(F("No Master Card Defined"));
|
||||
Serial.println(F("Scan A PICC to Define as Master Card"));
|
||||
do {
|
||||
successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0
|
||||
digitalWrite(blueLed, LED_ON); // Visualize Master Card need to be defined
|
||||
delay(200);
|
||||
digitalWrite(blueLed, LED_OFF);
|
||||
delay(200);
|
||||
}
|
||||
while (!successRead); // Program will not go further while you not get a successful read
|
||||
for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times
|
||||
EEPROM.write( 2 + j, readCard[j] ); // Write scanned PICC's UID to EEPROM, start from address 3
|
||||
}
|
||||
EEPROM.write(1, 143); // Write to EEPROM we defined Master Card.
|
||||
Serial.println(F("Master Card Defined"));
|
||||
}
|
||||
Serial.println(F("-------------------"));
|
||||
Serial.println(F("Master Card's UID"));
|
||||
for ( uint8_t i = 0; i < 4; i++ ) { // Read Master Card's UID from EEPROM
|
||||
masterCard[i] = EEPROM.read(2 + i); // Write it to masterCard
|
||||
Serial.print(masterCard[i], HEX);
|
||||
}
|
||||
Serial.println("");
|
||||
Serial.println(F("-------------------"));
|
||||
Serial.println(F("Everything is ready"));
|
||||
Serial.println(F("Waiting PICCs to be scanned"));
|
||||
cycleLeds(); // Everything ready lets give user some feedback by cycling leds
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////// Main Loop ///////////////////////////////////
|
||||
void loop () {
|
||||
do {
|
||||
successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0
|
||||
// When device is in use if wipe button pressed for 10 seconds initialize Master Card wiping
|
||||
if (digitalRead(wipeB) == LOW) { // Check if button is pressed
|
||||
// Visualize normal operation is iterrupted by pressing wipe button Red is like more Warning to user
|
||||
digitalWrite(redLed, LED_ON); // Make sure led is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure led is off
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure led is off
|
||||
// Give some feedback
|
||||
Serial.println(F("Wipe Button Pressed"));
|
||||
Serial.println(F("Master Card will be Erased! in 10 seconds"));
|
||||
bool buttonState = monitorWipeButton(10000); // Give user enough time to cancel operation
|
||||
if (buttonState == true && digitalRead(wipeB) == LOW) { // If button still be pressed, wipe EEPROM
|
||||
EEPROM.write(1, 0); // Reset Magic Number.
|
||||
Serial.println(F("Master Card Erased from device"));
|
||||
Serial.println(F("Please reset to re-program Master Card"));
|
||||
while (1);
|
||||
}
|
||||
Serial.println(F("Master Card Erase Cancelled"));
|
||||
}
|
||||
if (programMode) {
|
||||
cycleLeds(); // Program Mode cycles through Red Green Blue waiting to read a new card
|
||||
}
|
||||
else {
|
||||
normalModeOn(); // Normal mode, blue Power LED is on, all others are off
|
||||
}
|
||||
}
|
||||
while (!successRead); //the program will not go further while you are not getting a successful read
|
||||
if (programMode) {
|
||||
if ( isMaster(readCard) ) { //When in program mode check First If master card scanned again to exit program mode
|
||||
Serial.println(F("Master Card Scanned"));
|
||||
Serial.println(F("Exiting Program Mode"));
|
||||
Serial.println(F("-----------------------------"));
|
||||
programMode = false;
|
||||
return;
|
||||
}
|
||||
else {
|
||||
if ( findID(readCard) ) { // If scanned card is known delete it
|
||||
Serial.println(F("I know this PICC, removing..."));
|
||||
deleteID(readCard);
|
||||
Serial.println("-----------------------------");
|
||||
Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM"));
|
||||
}
|
||||
else { // If scanned card is not known add it
|
||||
Serial.println(F("I do not know this PICC, adding..."));
|
||||
writeID(readCard);
|
||||
Serial.println(F("-----------------------------"));
|
||||
Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM"));
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
if ( isMaster(readCard)) { // If scanned card's ID matches Master Card's ID - enter program mode
|
||||
programMode = true;
|
||||
Serial.println(F("Hello Master - Entered Program Mode"));
|
||||
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that
|
||||
Serial.print(F("I have ")); // stores the number of ID's in EEPROM
|
||||
Serial.print(count);
|
||||
Serial.print(F(" record(s) on EEPROM"));
|
||||
Serial.println("");
|
||||
Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM"));
|
||||
Serial.println(F("Scan Master Card again to Exit Program Mode"));
|
||||
Serial.println(F("-----------------------------"));
|
||||
}
|
||||
else {
|
||||
if ( findID(readCard) ) { // If not, see if the card is in the EEPROM
|
||||
Serial.println(F("Welcome, You shall pass"));
|
||||
granted(300); // Open the door lock for 300 ms
|
||||
}
|
||||
else { // If not, show that the ID was not valid
|
||||
Serial.println(F("You shall not pass"));
|
||||
denied();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Access Granted ///////////////////////////////////
|
||||
void granted ( uint16_t setDelay) {
|
||||
digitalWrite(blueLed, LED_OFF); // Turn off blue LED
|
||||
digitalWrite(redLed, LED_OFF); // Turn off red LED
|
||||
digitalWrite(greenLed, LED_ON); // Turn on green LED
|
||||
digitalWrite(relay, LOW); // Unlock door!
|
||||
delay(setDelay); // Hold door lock open for given seconds
|
||||
digitalWrite(relay, HIGH); // Relock door
|
||||
delay(1000); // Hold green LED on for a second
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Access Denied ///////////////////////////////////
|
||||
void denied() {
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
digitalWrite(redLed, LED_ON); // Turn on red LED
|
||||
delay(1000);
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////// Get PICC's UID ///////////////////////////////////
|
||||
uint8_t getID() {
|
||||
// Getting ready for Reading PICCs
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent()) { //If a new PICC placed to RFID reader continue
|
||||
return 0;
|
||||
}
|
||||
if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue
|
||||
return 0;
|
||||
}
|
||||
// There are Mifare PICCs which have 4 byte or 7 byte UID care if you use 7 byte PICC
|
||||
// I think we should assume every PICC as they have 4 byte UID
|
||||
// Until we support 7 byte PICCs
|
||||
Serial.println(F("Scanned PICC's UID:"));
|
||||
for ( uint8_t i = 0; i < 4; i++) { //
|
||||
readCard[i] = mfrc522.uid.uidByte[i];
|
||||
Serial.print(readCard[i], HEX);
|
||||
}
|
||||
Serial.println("");
|
||||
mfrc522.PICC_HaltA(); // Stop reading
|
||||
return 1;
|
||||
}
|
||||
|
||||
void ShowReaderDetails() {
|
||||
// Get the MFRC522 software version
|
||||
byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg);
|
||||
Serial.print(F("MFRC522 Software Version: 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(" (unknown),probably a chinese clone?"));
|
||||
Serial.println("");
|
||||
// When 0x00 or 0xFF is returned, communication probably failed
|
||||
if ((v == 0x00) || (v == 0xFF)) {
|
||||
Serial.println(F("WARNING: Communication failure, is the MFRC522 properly connected?"));
|
||||
Serial.println(F("SYSTEM HALTED: Check connections."));
|
||||
// Visualize system is halted
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
digitalWrite(redLed, LED_ON); // Turn on red LED
|
||||
while (true); // do not go further
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Cycle Leds (Program Mode) ///////////////////////////////////
|
||||
void cycleLeds() {
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_ON); // Make sure red LED is on
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
delay(200);
|
||||
}
|
||||
|
||||
//////////////////////////////////////// Normal Mode Led ///////////////////////////////////
|
||||
void normalModeOn () {
|
||||
digitalWrite(blueLed, LED_ON); // Blue LED ON and ready to read card
|
||||
digitalWrite(redLed, LED_OFF); // Make sure Red LED is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure Green LED is off
|
||||
digitalWrite(relay, HIGH); // Make sure Door is Locked
|
||||
}
|
||||
|
||||
//////////////////////////////////////// Read an ID from EEPROM //////////////////////////////
|
||||
void readID( uint8_t number ) {
|
||||
uint8_t start = (number * 4 ) + 2; // Figure out starting position
|
||||
for ( uint8_t i = 0; i < 4; i++ ) { // Loop 4 times to get the 4 Bytes
|
||||
storedCard[i] = EEPROM.read(start + i); // Assign values read from EEPROM to array
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Add ID to EEPROM ///////////////////////////////////
|
||||
void writeID( byte a[] ) {
|
||||
if ( !findID( a ) ) { // Before we write to the EEPROM, check to see if we have seen this card before!
|
||||
uint8_t num = EEPROM.read(0); // Get the numer of used spaces, position 0 stores the number of ID cards
|
||||
uint8_t start = ( num * 4 ) + 6; // Figure out where the next slot starts
|
||||
num++; // Increment the counter by one
|
||||
EEPROM.write( 0, num ); // Write the new count to the counter
|
||||
for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times
|
||||
EEPROM.write( start + j, a[j] ); // Write the array values to EEPROM in the right position
|
||||
}
|
||||
successWrite();
|
||||
Serial.println(F("Succesfully added ID record to EEPROM"));
|
||||
}
|
||||
else {
|
||||
failedWrite();
|
||||
Serial.println(F("Failed! There is something wrong with ID or bad EEPROM"));
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Remove ID from EEPROM ///////////////////////////////////
|
||||
void deleteID( byte a[] ) {
|
||||
if ( !findID( a ) ) { // Before we delete from the EEPROM, check to see if we have this card!
|
||||
failedWrite(); // If not
|
||||
Serial.println(F("Failed! There is something wrong with ID or bad EEPROM"));
|
||||
}
|
||||
else {
|
||||
uint8_t num = EEPROM.read(0); // Get the numer of used spaces, position 0 stores the number of ID cards
|
||||
uint8_t slot; // Figure out the slot number of the card
|
||||
uint8_t start; // = ( num * 4 ) + 6; // Figure out where the next slot starts
|
||||
uint8_t looping; // The number of times the loop repeats
|
||||
uint8_t j;
|
||||
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that stores number of cards
|
||||
slot = findIDSLOT( a ); // Figure out the slot number of the card to delete
|
||||
start = (slot * 4) + 2;
|
||||
looping = ((num - slot) * 4);
|
||||
num--; // Decrement the counter by one
|
||||
EEPROM.write( 0, num ); // Write the new count to the counter
|
||||
for ( j = 0; j < looping; j++ ) { // Loop the card shift times
|
||||
EEPROM.write( start + j, EEPROM.read(start + 4 + j)); // Shift the array values to 4 places earlier in the EEPROM
|
||||
}
|
||||
for ( uint8_t k = 0; k < 4; k++ ) { // Shifting loop
|
||||
EEPROM.write( start + j + k, 0);
|
||||
}
|
||||
successDelete();
|
||||
Serial.println(F("Succesfully removed ID record from EEPROM"));
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Check Bytes ///////////////////////////////////
|
||||
bool checkTwo ( byte a[], byte b[] ) {
|
||||
for ( uint8_t k = 0; k < 4; k++ ) { // Loop 4 times
|
||||
if ( a[k] != b[k] ) { // IF a != b then false, because: one fails, all fail
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Find Slot ///////////////////////////////////
|
||||
uint8_t findIDSLOT( byte find[] ) {
|
||||
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that
|
||||
for ( uint8_t i = 1; i <= count; i++ ) { // Loop once for each EEPROM entry
|
||||
readID(i); // Read an ID from EEPROM, it is stored in storedCard[4]
|
||||
if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM
|
||||
// is the same as the find[] ID card passed
|
||||
return i; // The slot number of the card
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Find ID From EEPROM ///////////////////////////////////
|
||||
bool findID( byte find[] ) {
|
||||
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that
|
||||
for ( uint8_t i = 1; i < count; i++ ) { // Loop once for each EEPROM entry
|
||||
readID(i); // Read an ID from EEPROM, it is stored in storedCard[4]
|
||||
if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM
|
||||
return true;
|
||||
}
|
||||
else { // If not, return false
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Write Success to EEPROM ///////////////////////////////////
|
||||
// Flashes the green LED 3 times to indicate a successful write to EEPROM
|
||||
void successWrite() {
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is on
|
||||
delay(200);
|
||||
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
|
||||
delay(200);
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
delay(200);
|
||||
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
|
||||
delay(200);
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
delay(200);
|
||||
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
|
||||
delay(200);
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Write Failed to EEPROM ///////////////////////////////////
|
||||
// Flashes the red LED 3 times to indicate a failed write to EEPROM
|
||||
void failedWrite() {
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_ON); // Make sure red LED is on
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_ON); // Make sure red LED is on
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
delay(200);
|
||||
digitalWrite(redLed, LED_ON); // Make sure red LED is on
|
||||
delay(200);
|
||||
}
|
||||
|
||||
///////////////////////////////////////// Success Remove UID From EEPROM ///////////////////////////////////
|
||||
// Flashes the blue LED 3 times to indicate a success delete to EEPROM
|
||||
void successDelete() {
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
|
||||
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
|
||||
delay(200);
|
||||
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
|
||||
delay(200);
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
delay(200);
|
||||
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
|
||||
delay(200);
|
||||
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
|
||||
delay(200);
|
||||
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
|
||||
delay(200);
|
||||
}
|
||||
|
||||
////////////////////// Check readCard IF is masterCard ///////////////////////////////////
|
||||
// Check to see if the ID passed is the master programing card
|
||||
bool isMaster( byte test[] ) {
|
||||
return checkTwo(test, masterCard);
|
||||
}
|
||||
|
||||
bool monitorWipeButton(uint32_t interval) {
|
||||
uint32_t now = (uint32_t)millis();
|
||||
while ((uint32_t)millis() - now < interval) {
|
||||
// check on every half a second
|
||||
if (((uint32_t)millis() % 500) == 0) {
|
||||
if (digitalRead(wipeB) != LOW)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
110
arduino-cli/libraries/MFRC522/examples/ChangeUID/ChangeUID.ino
Normal file
110
arduino-cli/libraries/MFRC522/examples/ChangeUID/ChangeUID.ino
Normal file
@@ -0,0 +1,110 @@
|
||||
/*
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* Example to change UID of changeable MIFARE card.
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
*
|
||||
* This sample shows how to set the UID on a UID changeable MIFARE card.
|
||||
*
|
||||
* @author Tom Clement
|
||||
* @license Released into the public domain.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
/* Set your new UID here! */
|
||||
#define NEW_UID {0xDE, 0xAD, 0xBE, 0xEF}
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
Serial.println(F("Warning: this example overwrites the UID of your UID changeable card, use with care!"));
|
||||
|
||||
// Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
|
||||
for (byte i = 0; i < 6; i++) {
|
||||
key.keyByte[i] = 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
// Setting the UID can be as simple as this:
|
||||
//void loop() {
|
||||
// byte newUid[] = NEW_UID;
|
||||
// if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
|
||||
// Serial.println("Wrote new UID to card.");
|
||||
// }
|
||||
// delay(1000);
|
||||
//}
|
||||
|
||||
// But of course this is a more proper approach
|
||||
void loop() {
|
||||
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle. And if present, select one.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
|
||||
delay(50);
|
||||
return;
|
||||
}
|
||||
|
||||
// Now a card is selected. The UID and SAK is in mfrc522.uid.
|
||||
|
||||
// Dump 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();
|
||||
|
||||
// Dump PICC type
|
||||
// MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
// Serial.print(F("PICC type: "));
|
||||
// Serial.print(mfrc522.PICC_GetTypeName(piccType));
|
||||
// Serial.print(F(" (SAK "));
|
||||
// Serial.print(mfrc522.uid.sak);
|
||||
// Serial.print(")\r\n");
|
||||
// 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;
|
||||
// }
|
||||
|
||||
// Set new 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;
|
||||
}
|
||||
|
||||
// Dump the new memory contents
|
||||
Serial.println(F("New UID and contents:"));
|
||||
mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
|
||||
|
||||
delay(2000);
|
||||
}
|
||||
67
arduino-cli/libraries/MFRC522/examples/DumpInfo/DumpInfo.ino
Normal file
67
arduino-cli/libraries/MFRC522/examples/DumpInfo/DumpInfo.ino
Normal file
@@ -0,0 +1,67 @@
|
||||
/*
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* Example sketch/program showing how to read data from a PICC to serial.
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
*
|
||||
* Example sketch/program showing how to read data from a PICC (that is: a RFID Tag or Card) using a MFRC522 based RFID
|
||||
* Reader on the Arduino SPI interface.
|
||||
*
|
||||
* When the Arduino and the MFRC522 module are connected (see the pin layout below), load this sketch into Arduino IDE
|
||||
* then verify/compile and upload it. To see the output: use Tools, Serial Monitor of the IDE (hit Ctrl+Shft+M). When
|
||||
* you present a PICC (that is: a RFID Tag or Card) at reading distance of the MFRC522 Reader/PCD, the serial output
|
||||
* will show the ID/UID, type and any data blocks it can read. Note: you may see "Timeout in communication" messages
|
||||
* when removing the PICC from reading distance too early.
|
||||
*
|
||||
* If your reader supports it, this sketch/program will read all the PICCs presented (that is: multiple tag reading).
|
||||
* So if you stack two or more PICCs on top of each other and present them to the reader, it will first output all
|
||||
* details of the first and then the next PICC. Note that this may take some time as all data blocks are dumped, so
|
||||
* keep the PICCs at reading distance until complete.
|
||||
*
|
||||
* @license Released into the public domain.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522
|
||||
delay(4); // Optional delay. Some board do need more time after init to be ready, see Readme
|
||||
mfrc522.PCD_DumpVersionToSerial(); // Show details of PCD - MFRC522 Card Reader details
|
||||
Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Dump debug info about the card; PICC_HaltA() is automatically called
|
||||
mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* Example sketch/program to fix a broken UID changeable MIFARE cards.
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
*
|
||||
* This sample shows how to fix a broken UID changeable MIFARE cards that have a corrupted sector 0.
|
||||
*
|
||||
* @author Tom Clement
|
||||
* @license Released into the public domain.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
Serial.println(F("Warning: this example clears your mifare UID, use with care!"));
|
||||
|
||||
// Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
|
||||
for (byte i = 0; i < 6; i++) {
|
||||
key.keyByte[i] = 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
void loop() {
|
||||
if ( mfrc522.MIFARE_UnbrickUidSector(false) ) {
|
||||
Serial.println(F("Cleared sector 0, set UID to 1234. Card should be responsive again now."));
|
||||
}
|
||||
delay(1000);
|
||||
}
|
||||
@@ -0,0 +1,319 @@
|
||||
/**
|
||||
* ----------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; see https://github.com/miguelbalboa/rfid
|
||||
* for further details and other examples.
|
||||
*
|
||||
* NOTE: The library file MFRC522.h has a lot of useful info. Please read it.
|
||||
*
|
||||
* Released into the public domain.
|
||||
* ----------------------------------------------------------------------------
|
||||
* This sample shows how to setup blocks on a MIFARE Classic PICC (= card/tag)
|
||||
* to be in "Value Block" mode: in this mode the operations Increment/Decrement,
|
||||
* Restore and Transfer can be used.
|
||||
*
|
||||
* BEWARE: Data will be written to the PICC, in sector #1 (blocks #4 to #7).
|
||||
*
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
/**
|
||||
* Initialize.
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
|
||||
// Prepare the key (used both as key A and as key B)
|
||||
// using FFFFFFFFFFFFh which is the default at chip delivery from the factory
|
||||
for (byte i = 0; i < 6; i++) {
|
||||
key.keyByte[i] = 0xFF;
|
||||
}
|
||||
|
||||
Serial.println(F("Scan a MIFARE Classic PICC to demonstrate Value Block mode."));
|
||||
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"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Main loop.
|
||||
*/
|
||||
void loop() {
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent())
|
||||
return;
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial())
|
||||
return;
|
||||
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F("Card UID:"));
|
||||
dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
Serial.println(mfrc522.PICC_GetTypeName(piccType));
|
||||
|
||||
// Check for compatibility
|
||||
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;
|
||||
}
|
||||
|
||||
// In this sample we use the second sector,
|
||||
// that is: sector #1, covering block #4 up to and including block #7
|
||||
byte sector = 1;
|
||||
byte valueBlockA = 5;
|
||||
byte valueBlockB = 6;
|
||||
byte trailerBlock = 7;
|
||||
MFRC522::StatusCode status;
|
||||
byte buffer[18];
|
||||
byte size = sizeof(buffer);
|
||||
int32_t value;
|
||||
|
||||
// Authenticate using key A
|
||||
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;
|
||||
}
|
||||
|
||||
// Show the whole sector as it currently is
|
||||
Serial.println(F("Current data in sector:"));
|
||||
mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
|
||||
Serial.println();
|
||||
|
||||
// We need a sector trailer that defines blocks 5 and 6 as Value Blocks and enables key B
|
||||
// The last block in a sector (block #3 for Mifare Classic 1K) is the Sector Trailer.
|
||||
// See http://www.nxp.com/documents/data_sheet/MF1S503x.pdf sections 8.6 and 8.7:
|
||||
// Bytes 0-5: Key A
|
||||
// Bytes 6-8: Access Bits
|
||||
// Bytes 9: User data
|
||||
// Bytes 10-15: Key B (or user data)
|
||||
byte trailerBuffer[] = {
|
||||
255, 255, 255, 255, 255, 255, // Keep default key A
|
||||
0, 0, 0,
|
||||
0,
|
||||
255, 255, 255, 255, 255, 255}; // Keep default key B
|
||||
// The access bits are stored in a peculiar fashion.
|
||||
// There are four groups:
|
||||
// g[0] Access bits for block 0 (for sectors 0-31)
|
||||
// or blocks 0-4 (for sectors 32-39)
|
||||
// g[1] Access bits for block 1 (for sectors 0-31)
|
||||
// or blocks 5-9 (for sectors 32-39)
|
||||
// g[2] Access bits for block 2 (for sectors 0-31)
|
||||
// or blocks 10-14 (for sectors 32-39)
|
||||
// g[3] Access bits for the Sector Trailer: block 3 (for sectors 0-31)
|
||||
// or block 15 (for sectors 32-39)
|
||||
// Each group has access bits [C1 C2 C3], in this code C1 is MSB and C3 is LSB.
|
||||
// Determine the bit pattern needed using MIFARE_SetAccessBits:
|
||||
// g0=0 access bits for block 0 (of this sector) using [0 0 0] = 000b = 0
|
||||
// which means key A|B have r/w for block 0 of this sector
|
||||
// which (in this example) translates to block #4 within sector #1;
|
||||
// this is the transport configuration (at factory delivery).
|
||||
// g1=6 access bits for block 1 (of this sector) using [1 1 0] = 110b = 6
|
||||
// which means block 1 (of this sector) is used as a value block,
|
||||
// which (in this example) translates to block #5 within sector #1;
|
||||
// where key A|B have r, key B has w, key B can increment,
|
||||
// and key A|B can decrement, transfer, and restore.
|
||||
// g2=6 same thing for block 2 (of this sector): set it to a value block;
|
||||
// which (in this example) translates to block #6 within sector #1;
|
||||
// g3=3 access bits for block 3 (of this sector): the Sector Trailer here;
|
||||
// using [0 1 1] = 011b = 3 which means only key B has r/w access
|
||||
// to the Sector Trailer (block 3 of this sector) from now on
|
||||
// which (in this example) translates to block #7 within sector #1;
|
||||
mfrc522.MIFARE_SetAccessBits(&trailerBuffer[6], 0, 6, 6, 3);
|
||||
|
||||
// Read the sector trailer as it is currently stored on the PICC
|
||||
Serial.println(F("Reading sector trailer..."));
|
||||
status = mfrc522.MIFARE_Read(trailerBlock, buffer, &size);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Read() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
// Check if it matches the desired access pattern already;
|
||||
// because if it does, we don't need to write it again...
|
||||
if ( buffer[6] != trailerBuffer[6]
|
||||
|| buffer[7] != trailerBuffer[7]
|
||||
|| buffer[8] != trailerBuffer[8]) {
|
||||
// They don't match (yet), so write it to the PICC
|
||||
Serial.println(F("Writing new sector trailer..."));
|
||||
status = mfrc522.MIFARE_Write(trailerBlock, trailerBuffer, 16);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Write() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Authenticate using key B
|
||||
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;
|
||||
}
|
||||
|
||||
// A value block has a 32 bit signed value stored three times
|
||||
// and an 8 bit address stored 4 times. Make sure that valueBlockA
|
||||
// and valueBlockB have that format (note that it will only format
|
||||
// the block when it doesn't comply to the expected format already).
|
||||
formatValueBlock(valueBlockA);
|
||||
formatValueBlock(valueBlockB);
|
||||
|
||||
// Add 1 to the value of valueBlockA and store the result in valueBlockA.
|
||||
Serial.print("Adding 1 to value of block "); Serial.println(valueBlockA);
|
||||
status = mfrc522.MIFARE_Increment(valueBlockA, 1);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Increment() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
status = mfrc522.MIFARE_Transfer(valueBlockA);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Transfer() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
// Show the new value of valueBlockA
|
||||
status = mfrc522.MIFARE_GetValue(valueBlockA, &value);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("mifare_GetValue() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
Serial.print("New value of value block "); Serial.print(valueBlockA);
|
||||
Serial.print(" = "); Serial.println(value);
|
||||
|
||||
// Decrement 10 from the value of valueBlockB and store the result in valueBlockB.
|
||||
Serial.print("Subtracting 10 from value of block "); Serial.println(valueBlockB);
|
||||
status = mfrc522.MIFARE_Decrement(valueBlockB, 10);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Decrement() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
status = mfrc522.MIFARE_Transfer(valueBlockB);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Transfer() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
// Show the new value of valueBlockB
|
||||
status = mfrc522.MIFARE_GetValue(valueBlockB, &value);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("mifare_GetValue() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
Serial.print(F("New value of value block ")); Serial.print(valueBlockB);
|
||||
Serial.print(F(" = ")); Serial.println(value);
|
||||
// Check some boundary...
|
||||
if (value <= -100) {
|
||||
Serial.println(F("Below -100, so resetting it to 255 = 0xFF just for fun..."));
|
||||
status = mfrc522.MIFARE_SetValue(valueBlockB, 255);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("mifare_SetValue() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Dump the sector data
|
||||
mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
|
||||
Serial.println();
|
||||
|
||||
// Halt PICC
|
||||
mfrc522.PICC_HaltA();
|
||||
// Stop encryption on PCD
|
||||
mfrc522.PCD_StopCrypto1();
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper routine to dump a byte array as hex values to Serial.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure that a given block is formatted as a Value Block.
|
||||
*/
|
||||
void formatValueBlock(byte blockAddr) {
|
||||
byte buffer[18];
|
||||
byte size = sizeof(buffer);
|
||||
MFRC522::StatusCode status;
|
||||
|
||||
Serial.print(F("Reading block ")); Serial.println(blockAddr);
|
||||
status = mfrc522.MIFARE_Read(blockAddr, buffer, &size);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Read() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
|
||||
if ( (buffer[0] == (byte)~buffer[4])
|
||||
&& (buffer[1] == (byte)~buffer[5])
|
||||
&& (buffer[2] == (byte)~buffer[6])
|
||||
&& (buffer[3] == (byte)~buffer[7])
|
||||
|
||||
&& (buffer[0] == buffer[8])
|
||||
&& (buffer[1] == buffer[9])
|
||||
&& (buffer[2] == buffer[10])
|
||||
&& (buffer[3] == buffer[11])
|
||||
|
||||
&& (buffer[12] == (byte)~buffer[13])
|
||||
&& (buffer[12] == buffer[14])
|
||||
&& (buffer[12] == (byte)~buffer[15])) {
|
||||
Serial.println(F("Block has correct Value Block format."));
|
||||
}
|
||||
else {
|
||||
Serial.println(F("Formatting as Value Block..."));
|
||||
byte valueBlock[] = {
|
||||
0, 0, 0, 0,
|
||||
255, 255, 255, 255,
|
||||
0, 0, 0, 0,
|
||||
blockAddr, ~blockAddr, blockAddr, ~blockAddr };
|
||||
status = mfrc522.MIFARE_Write(blockAddr, valueBlock, 16);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Write() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
/**
|
||||
* ----------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; see https://github.com/miguelbalboa/rfid
|
||||
* for further details and other examples.
|
||||
*
|
||||
* NOTE: The library file MFRC522.h has a lot of useful info. Please read it.
|
||||
*
|
||||
* Released into the public domain.
|
||||
* ----------------------------------------------------------------------------
|
||||
* Minimal example how to use the interrupts to read the UID of a MIFARE Classic PICC
|
||||
* (= card/tag).
|
||||
*
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 3 10
|
||||
* IRQ ? ? ? ? 2 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 3 // Configurable, see typical pin layout above
|
||||
#define IRQ_PIN 2 // Configurable, depends on hardware
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
volatile bool bNewInt = false;
|
||||
byte regVal = 0x7F;
|
||||
void activateRec(MFRC522 mfrc522);
|
||||
void clearInt(MFRC522 mfrc522);
|
||||
|
||||
/**
|
||||
* Initialize.
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(115200); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
|
||||
/* read and printout the MFRC522 version (valid values 0x91 & 0x92)*/
|
||||
Serial.print(F("Ver: 0x"));
|
||||
byte readReg = mfrc522.PCD_ReadRegister(mfrc522.VersionReg);
|
||||
Serial.println(readReg, HEX);
|
||||
|
||||
/* setup the IRQ pin*/
|
||||
pinMode(IRQ_PIN, INPUT_PULLUP);
|
||||
|
||||
/*
|
||||
* Allow the ... irq to be propagated to the IRQ pin
|
||||
* For test purposes propagate the IdleIrq and loAlert
|
||||
*/
|
||||
regVal = 0xA0; //rx irq
|
||||
mfrc522.PCD_WriteRegister(mfrc522.ComIEnReg, regVal);
|
||||
|
||||
bNewInt = false; //interrupt flag
|
||||
|
||||
/*Activate the interrupt*/
|
||||
attachInterrupt(digitalPinToInterrupt(IRQ_PIN), readCard, FALLING);
|
||||
|
||||
do { //clear a spourious interrupt at start
|
||||
;
|
||||
} while (!bNewInt);
|
||||
bNewInt = false;
|
||||
|
||||
Serial.println(F("End setup"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Main loop.
|
||||
*/
|
||||
void loop() {
|
||||
if (bNewInt) { //new read interrupt
|
||||
Serial.print(F("Interrupt. "));
|
||||
mfrc522.PICC_ReadCardSerial(); //read the tag data
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F("Card UID:"));
|
||||
dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
|
||||
Serial.println();
|
||||
|
||||
clearInt(mfrc522);
|
||||
mfrc522.PICC_HaltA();
|
||||
bNewInt = false;
|
||||
}
|
||||
|
||||
// The receiving block needs regular retriggering (tell the tag it should transmit??)
|
||||
// (mfrc522.PCD_WriteRegister(mfrc522.FIFODataReg,mfrc522.PICC_CMD_REQA);)
|
||||
activateRec(mfrc522);
|
||||
delay(100);
|
||||
} //loop()
|
||||
|
||||
/**
|
||||
* Helper routine to dump a byte array as hex values to Serial.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* MFRC522 interrupt serving routine
|
||||
*/
|
||||
void readCard() {
|
||||
bNewInt = true;
|
||||
}
|
||||
|
||||
/*
|
||||
* The function sending to the MFRC522 the needed commands to activate the reception
|
||||
*/
|
||||
void activateRec(MFRC522 mfrc522) {
|
||||
mfrc522.PCD_WriteRegister(mfrc522.FIFODataReg, mfrc522.PICC_CMD_REQA);
|
||||
mfrc522.PCD_WriteRegister(mfrc522.CommandReg, mfrc522.PCD_Transceive);
|
||||
mfrc522.PCD_WriteRegister(mfrc522.BitFramingReg, 0x87);
|
||||
}
|
||||
|
||||
/*
|
||||
* The function to clear the pending interrupt bits after interrupt serving routine
|
||||
*/
|
||||
void clearInt(MFRC522 mfrc522) {
|
||||
mfrc522.PCD_WriteRegister(mfrc522.ComIrqReg, 0x7F);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* This example show how you can get Authenticated by the NTAG213,215,216. By default the tags are unprotected in order to protect them we need to write 4 different values:
|
||||
* Using mfrc522.MIFARE_Ultralight_Write(PageNum, Data, #Databytes))
|
||||
* 1.- We need to write the 32bit passWord to page 0xE5 !for ntag 213 and 215 page is different refer to nxp documentation!
|
||||
* 2.- Now Write the 16 bits pACK to the page 0xE6 use the 2 high bytes like this: pACKH + pACKL + 00 + 00 after an authentication the tag will return this secret bytes
|
||||
* 3.- Now we need to write the first page we want to protect this is a 1 byte data in page 0xE3 we need to write 00 + 00 + 00 + firstPage all pages after this one are write protected
|
||||
* Now WRITE protection is ACTIVATED so we need to get authenticated in order to write the last data
|
||||
* 4.- Finally we need to write an access record in order to READ protect the card this step is optional only if you want to read protect also write 80 + 00 + 00 + 00 to 0xE4
|
||||
* After completing all these steps you will nee to authenticate first in order to read or write ant page after the first page you selected to protect.
|
||||
* To disengage protection just write the page (0xE3) to 00 + 00 + 00 + FF that going to remove all protection.
|
||||
*
|
||||
* @author GARGANTUA from RoboCreators.com & paradoxalabs.com
|
||||
* @license Released into the public domain.
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 //
|
||||
#define SS_PIN 10 //
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522
|
||||
Serial.println(F("Scan PICC to see UID, type, and data blocks..."));
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial()) {
|
||||
return;
|
||||
}
|
||||
|
||||
byte PSWBuff[] = {0xFF, 0xFF, 0xFF, 0xFF}; // 32 bit password default FFFFFFFF.
|
||||
byte pACK[] = {0, 0}; // 16 bit password ACK returned by the NFCtag.
|
||||
|
||||
Serial.print("Auth: ");
|
||||
Serial.println(mfrc522.PCD_NTAG216_AUTH(&PSWBuff[0], pACK)); // Request authentification if return STATUS_OK we are good.
|
||||
|
||||
//Print PassWordACK
|
||||
Serial.print(pACK[0], HEX);
|
||||
Serial.println(pACK[1], HEX);
|
||||
|
||||
byte WBuff[] = {0x00, 0x00, 0x00, 0x04};
|
||||
byte RBuff[18];
|
||||
|
||||
//Serial.print("CHG BLK: ");
|
||||
//Serial.println(mfrc522.MIFARE_Ultralight_Write(0xE3, WBuff, 4)); // How to write to a page.
|
||||
|
||||
mfrc522.PICC_DumpMifareUltralightToSerial(); // This is a modifier dump just change the for circle to < 232 instead of < 16 in order to see all the pages on NTAG216.
|
||||
|
||||
delay(3000);
|
||||
}
|
||||
@@ -0,0 +1,312 @@
|
||||
/*
|
||||
* Copy the RFID card data into variables and then
|
||||
* scan the second empty card to copy all the data
|
||||
* ----------------------------------------------------------------------------
|
||||
* Example sketch/program which will try the most used default keys listed in
|
||||
* https://code.google.com/p/mfcuk/wiki/MifareClassicDefaultKeys to dump the
|
||||
* block 0 of a MIFARE RFID card using a RFID-RC522 reader.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
|
||||
|
||||
byte buffer[18];
|
||||
byte block;
|
||||
byte waarde[64][16];
|
||||
MFRC522::StatusCode status;
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
// Number of known default keys (hard-coded)
|
||||
// NOTE: Synchronize the NR_KNOWN_KEYS define with the defaultKeys[] array
|
||||
#define NR_KNOWN_KEYS 8
|
||||
// Known keys, see: https://code.google.com/p/mfcuk/wiki/MifareClassicDefaultKeys
|
||||
byte knownKeys[NR_KNOWN_KEYS][MFRC522::MF_KEY_SIZE] = {
|
||||
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, // FF FF FF FF FF FF = factory default
|
||||
{0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5}, // A0 A1 A2 A3 A4 A5
|
||||
{0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5}, // B0 B1 B2 B3 B4 B5
|
||||
{0x4d, 0x3a, 0x99, 0xc3, 0x51, 0xdd}, // 4D 3A 99 C3 51 DD
|
||||
{0x1a, 0x98, 0x2c, 0x7e, 0x45, 0x9a}, // 1A 98 2C 7E 45 9A
|
||||
{0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7}, // D3 F7 D3 F7 D3 F7
|
||||
{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}, // AA BB CC DD EE FF
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // 00 00 00 00 00 00
|
||||
};
|
||||
|
||||
char choice;
|
||||
/*
|
||||
* Initialize.
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
Serial.println(F("Try the most used default keys to print block 0 to 63 of a MIFARE PICC."));
|
||||
Serial.println("1.Read card \n2.Write to card \n3.Copy the data.");
|
||||
|
||||
for (byte i = 0; i < 6; i++) {
|
||||
key.keyByte[i] = 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//Via seriele monitor de bytes uitlezen in hexadecimaal
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
//Via seriele monitor de bytes uitlezen in ASCI
|
||||
|
||||
void dump_byte_array1(byte *buffer, byte bufferSize) {
|
||||
for (byte i = 0; i < bufferSize; i++) {
|
||||
Serial.print(buffer[i] < 0x10 ? " 0" : " ");
|
||||
Serial.write(buffer[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Try using the PICC (the tag/card) with the given key to access block 0 to 63.
|
||||
* On success, it will show the key details, and dump the block data on Serial.
|
||||
*
|
||||
* @return true when the given key worked, false otherwise.
|
||||
*/
|
||||
|
||||
bool try_key(MFRC522::MIFARE_Key *key)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
for(byte block = 0; block < 64; block++){
|
||||
|
||||
// Serial.println(F("Authenticating using key 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 false;
|
||||
}
|
||||
|
||||
// Read block
|
||||
byte byteCount = sizeof(buffer);
|
||||
status = mfrc522.MIFARE_Read(block, buffer, &byteCount);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Read() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
}
|
||||
else {
|
||||
// Successful read
|
||||
result = true;
|
||||
Serial.print(F("Success with key:"));
|
||||
dump_byte_array((*key).keyByte, MFRC522::MF_KEY_SIZE);
|
||||
Serial.println();
|
||||
|
||||
// Dump block data
|
||||
Serial.print(F("Block ")); Serial.print(block); Serial.print(F(":"));
|
||||
dump_byte_array1(buffer, 16); //omzetten van hex naar ASCI
|
||||
Serial.println();
|
||||
|
||||
for (int p = 0; p < 16; p++) //De 16 bits uit de block uitlezen
|
||||
{
|
||||
waarde [block][p] = buffer[p];
|
||||
Serial.print(waarde[block][p]);
|
||||
Serial.print(" ");
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Serial.println();
|
||||
|
||||
Serial.println("1.Read card \n2.Write to card \n3.Copy the data.");
|
||||
|
||||
mfrc522.PICC_HaltA(); // Halt PICC
|
||||
mfrc522.PCD_StopCrypto1(); // Stop encryption on PCD
|
||||
return result;
|
||||
|
||||
start();
|
||||
}
|
||||
|
||||
/*
|
||||
* Main loop.
|
||||
*/
|
||||
void loop() {
|
||||
start();
|
||||
|
||||
}
|
||||
|
||||
void start(){
|
||||
choice = Serial.read();
|
||||
|
||||
if(choice == '1')
|
||||
{
|
||||
Serial.println("Read the card");
|
||||
keuze1();
|
||||
|
||||
}
|
||||
else if(choice == '2')
|
||||
{
|
||||
Serial.println("See what is in the variables");
|
||||
keuze2();
|
||||
}
|
||||
else if(choice == '3')
|
||||
{
|
||||
Serial.println("Copying the data on to the new card");
|
||||
keuze3();
|
||||
}
|
||||
}
|
||||
|
||||
void keuze2(){ //Test waardes in blokken
|
||||
|
||||
for(block = 4; block <= 62; block++){
|
||||
if(block == 7 || block == 11 || block == 15 || block == 19 || block == 23 || block == 27 || block == 31 || block == 35 || block == 39 || block == 43 || block == 47 || block == 51 || block == 55 || block == 59){
|
||||
block ++;
|
||||
}
|
||||
|
||||
Serial.print(F("Writing data into block "));
|
||||
Serial.print(block);
|
||||
Serial.println("\n");
|
||||
|
||||
for(int j = 0; j < 16; j++){
|
||||
Serial.print(waarde[block][j]);
|
||||
Serial.print(" ");
|
||||
}
|
||||
Serial.println("\n");
|
||||
|
||||
}
|
||||
|
||||
Serial.println("1.Read card \n2.Write to card \n3.Copy the data.");
|
||||
start();
|
||||
}
|
||||
|
||||
void keuze3(){ //Copy the data in the new card
|
||||
Serial.println("Insert new card...");
|
||||
// Look for new cards
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent())
|
||||
return;
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial())
|
||||
return;
|
||||
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F("Card UID:"));
|
||||
dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
Serial.println(mfrc522.PICC_GetTypeName(piccType));
|
||||
|
||||
// Try the known default keys
|
||||
/*MFRC522::MIFARE_Key key;
|
||||
for (byte k = 0; k < NR_KNOWN_KEYS; k++) {
|
||||
// Copy the known key into the MIFARE_Key structure
|
||||
for (byte i = 0; i < MFRC522::MF_KEY_SIZE; i++) {
|
||||
key.keyByte[i] = knownKeys[k][i];
|
||||
}
|
||||
}*/
|
||||
for (byte i = 0; i < 6; i++) {
|
||||
key.keyByte[i] = 0xFF;
|
||||
}
|
||||
|
||||
for(int i = 4; i <= 62; i++){ //De blocken 4 tot 62 kopieren, behalve al deze onderstaande blocken (omdat deze de authenticatie blokken zijn)
|
||||
if(i == 7 || i == 11 || i == 15 || i == 19 || i == 23 || i == 27 || i == 31 || i == 35 || i == 39 || i == 43 || i == 47 || i == 51 || i == 55 || i == 59){
|
||||
i++;
|
||||
}
|
||||
block = i;
|
||||
|
||||
// Authenticate using key A
|
||||
Serial.println(F("Authenticating using key A..."));
|
||||
status = (MFRC522::StatusCode) 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;
|
||||
}
|
||||
|
||||
// Authenticate using key B
|
||||
Serial.println(F("Authenticating again using key B..."));
|
||||
status = (MFRC522::StatusCode) mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, block, &key, &(mfrc522.uid));
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("PCD_Authenticate() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
|
||||
// Write data to the block
|
||||
Serial.print(F("Writing data into block "));
|
||||
Serial.print(block);
|
||||
Serial.println("\n");
|
||||
|
||||
dump_byte_array(waarde[block], 16);
|
||||
|
||||
|
||||
status = (MFRC522::StatusCode) mfrc522.MIFARE_Write(block, waarde[block], 16);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Write() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
}
|
||||
|
||||
|
||||
Serial.println("\n");
|
||||
|
||||
}
|
||||
mfrc522.PICC_HaltA(); // Halt PICC
|
||||
mfrc522.PCD_StopCrypto1(); // Stop encryption on PCD
|
||||
|
||||
Serial.println("1.Read card \n2.Write to card \n3.Copy the data.");
|
||||
start();
|
||||
}
|
||||
|
||||
void keuze1(){ //Read card
|
||||
Serial.println("Insert card...");
|
||||
// Look for new cards
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent())
|
||||
return;
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial())
|
||||
return;
|
||||
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F("Card UID:"));
|
||||
dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
Serial.println(mfrc522.PICC_GetTypeName(piccType));
|
||||
|
||||
// Try the known default keys
|
||||
MFRC522::MIFARE_Key key;
|
||||
for (byte k = 0; k < NR_KNOWN_KEYS; k++) {
|
||||
// Copy the known key into the MIFARE_Key structure
|
||||
for (byte i = 0; i < MFRC522::MF_KEY_SIZE; i++) {
|
||||
key.keyByte[i] = knownKeys[k][i];
|
||||
}
|
||||
// Try the key
|
||||
if (try_key(&key)) {
|
||||
// Found and reported on the key and block,
|
||||
// no need to try other keys for this PICC
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
/**
|
||||
* ----------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; see https://github.com/miguelbalboa/rfid
|
||||
* for further details and other examples.
|
||||
*
|
||||
* NOTE: The library file MFRC522.h has a lot of useful info. Please read it.
|
||||
*
|
||||
* Released into the public domain.
|
||||
* ----------------------------------------------------------------------------
|
||||
* This sample shows how to read and write data blocks on a MIFARE Classic PICC
|
||||
* (= card/tag).
|
||||
*
|
||||
* BEWARE: Data will be written to the PICC, in sector #1 (blocks #4 to #7).
|
||||
*
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
/**
|
||||
* Initialize.
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
|
||||
// Prepare the key (used both as key A and as key B)
|
||||
// using FFFFFFFFFFFFh which is the default at chip delivery from the factory
|
||||
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"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Main loop.
|
||||
*/
|
||||
void loop() {
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent())
|
||||
return;
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial())
|
||||
return;
|
||||
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F("Card UID:"));
|
||||
dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
Serial.println(mfrc522.PICC_GetTypeName(piccType));
|
||||
|
||||
// Check for compatibility
|
||||
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;
|
||||
}
|
||||
|
||||
// In this sample we use the second sector,
|
||||
// that is: sector #1, covering block #4 up to and including block #7
|
||||
byte sector = 1;
|
||||
byte blockAddr = 4;
|
||||
byte dataBlock[] = {
|
||||
0x01, 0x02, 0x03, 0x04, // 1, 2, 3, 4,
|
||||
0x05, 0x06, 0x07, 0x08, // 5, 6, 7, 8,
|
||||
0x09, 0x0a, 0xff, 0x0b, // 9, 10, 255, 11,
|
||||
0x0c, 0x0d, 0x0e, 0x0f // 12, 13, 14, 15
|
||||
};
|
||||
byte trailerBlock = 7;
|
||||
MFRC522::StatusCode status;
|
||||
byte buffer[18];
|
||||
byte size = sizeof(buffer);
|
||||
|
||||
// Authenticate using key A
|
||||
Serial.println(F("Authenticating using key A..."));
|
||||
status = (MFRC522::StatusCode) 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;
|
||||
}
|
||||
|
||||
// Show the whole sector as it currently is
|
||||
Serial.println(F("Current data in sector:"));
|
||||
mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
|
||||
Serial.println();
|
||||
|
||||
// Read data from the block
|
||||
Serial.print(F("Reading data from block ")); Serial.print(blockAddr);
|
||||
Serial.println(F(" ..."));
|
||||
status = (MFRC522::StatusCode) 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();
|
||||
|
||||
// Authenticate using key B
|
||||
Serial.println(F("Authenticating again using key B..."));
|
||||
status = (MFRC522::StatusCode) 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;
|
||||
}
|
||||
|
||||
// Write data to the block
|
||||
Serial.print(F("Writing data into block ")); Serial.print(blockAddr);
|
||||
Serial.println(F(" ..."));
|
||||
dump_byte_array(dataBlock, 16); Serial.println();
|
||||
status = (MFRC522::StatusCode) mfrc522.MIFARE_Write(blockAddr, dataBlock, 16);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Write() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
}
|
||||
Serial.println();
|
||||
|
||||
// Read data from the block (again, should now be what we have written)
|
||||
Serial.print(F("Reading data from block ")); Serial.print(blockAddr);
|
||||
Serial.println(F(" ..."));
|
||||
status = (MFRC522::StatusCode) 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();
|
||||
|
||||
// Check that data in block is what we have written
|
||||
// by counting the number of bytes that are equal
|
||||
Serial.println(F("Checking result..."));
|
||||
byte count = 0;
|
||||
for (byte i = 0; i < 16; i++) {
|
||||
// Compare buffer (= what we've read) with dataBlock (= what we've written)
|
||||
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();
|
||||
|
||||
// Dump the sector data
|
||||
Serial.println(F("Current data in sector:"));
|
||||
mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
|
||||
Serial.println();
|
||||
|
||||
// Halt PICC
|
||||
mfrc522.PICC_HaltA();
|
||||
// Stop encryption on PCD
|
||||
mfrc522.PCD_StopCrypto1();
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper routine to dump a byte array as hex values to Serial.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
127
arduino-cli/libraries/MFRC522/examples/ReadNUID/ReadNUID.ino
Normal file
127
arduino-cli/libraries/MFRC522/examples/ReadNUID/ReadNUID.ino
Normal file
@@ -0,0 +1,127 @@
|
||||
/*
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* Example sketch/program showing how to read new NUID from a PICC to serial.
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
*
|
||||
* Example sketch/program showing how to the read data from a PICC (that is: a RFID Tag or Card) using a MFRC522 based RFID
|
||||
* Reader on the Arduino SPI interface.
|
||||
*
|
||||
* When the Arduino and the MFRC522 module are connected (see the pin layout below), load this sketch into Arduino IDE
|
||||
* then verify/compile and upload it. To see the output: use Tools, Serial Monitor of the IDE (hit Ctrl+Shft+M). When
|
||||
* you present a PICC (that is: a RFID Tag or Card) at reading distance of the MFRC522 Reader/PCD, the serial output
|
||||
* will show the type, and the NUID if a new card has been detected. Note: you may see "Timeout in communication" messages
|
||||
* when removing the PICC from reading distance too early.
|
||||
*
|
||||
* @license Released into the public domain.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define SS_PIN 10
|
||||
#define RST_PIN 9
|
||||
|
||||
MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class
|
||||
|
||||
MFRC522::MIFARE_Key key;
|
||||
|
||||
// Init array that will store new NUID
|
||||
byte nuidPICC[4];
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600);
|
||||
SPI.begin(); // Init SPI bus
|
||||
rfid.PCD_Init(); // Init MFRC522
|
||||
|
||||
for (byte i = 0; i < 6; i++) {
|
||||
key.keyByte[i] = 0xFF;
|
||||
}
|
||||
|
||||
Serial.println(F("This code scan the MIFARE Classsic NUID."));
|
||||
Serial.print(F("Using the following key:"));
|
||||
printHex(key.keyByte, MFRC522::MF_KEY_SIZE);
|
||||
}
|
||||
|
||||
void loop() {
|
||||
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! rfid.PICC_IsNewCardPresent())
|
||||
return;
|
||||
|
||||
// Verify if the NUID has been readed
|
||||
if ( ! rfid.PICC_ReadCardSerial())
|
||||
return;
|
||||
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
|
||||
Serial.println(rfid.PICC_GetTypeName(piccType));
|
||||
|
||||
// Check is the PICC of Classic MIFARE type
|
||||
if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&
|
||||
piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
|
||||
piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
|
||||
Serial.println(F("Your tag is not of type MIFARE Classic."));
|
||||
return;
|
||||
}
|
||||
|
||||
if (rfid.uid.uidByte[0] != nuidPICC[0] ||
|
||||
rfid.uid.uidByte[1] != nuidPICC[1] ||
|
||||
rfid.uid.uidByte[2] != nuidPICC[2] ||
|
||||
rfid.uid.uidByte[3] != nuidPICC[3] ) {
|
||||
Serial.println(F("A new card has been detected."));
|
||||
|
||||
// Store NUID into nuidPICC array
|
||||
for (byte i = 0; i < 4; i++) {
|
||||
nuidPICC[i] = rfid.uid.uidByte[i];
|
||||
}
|
||||
|
||||
Serial.println(F("The NUID tag is:"));
|
||||
Serial.print(F("In hex: "));
|
||||
printHex(rfid.uid.uidByte, rfid.uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("In dec: "));
|
||||
printDec(rfid.uid.uidByte, rfid.uid.size);
|
||||
Serial.println();
|
||||
}
|
||||
else Serial.println(F("Card read previously."));
|
||||
|
||||
// Halt PICC
|
||||
rfid.PICC_HaltA();
|
||||
|
||||
// Stop encryption on PCD
|
||||
rfid.PCD_StopCrypto1();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Helper routine to dump a byte array as hex values to Serial.
|
||||
*/
|
||||
void printHex(byte *buffer, byte bufferSize) {
|
||||
for (byte i = 0; i < bufferSize; i++) {
|
||||
Serial.print(buffer[i] < 0x10 ? " 0" : " ");
|
||||
Serial.print(buffer[i], HEX);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper routine to dump a byte array as dec values to Serial.
|
||||
*/
|
||||
void printDec(byte *buffer, byte bufferSize) {
|
||||
for (byte i = 0; i < bufferSize; i++) {
|
||||
Serial.print(buffer[i] < 0x10 ? " 0" : " ");
|
||||
Serial.print(buffer[i], DEC);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
/**
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* Example sketch/program showing how to read data from more than one PICC to serial.
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
*
|
||||
* Example sketch/program showing how to read data from more than one PICC (that is: a RFID Tag or Card) using a
|
||||
* MFRC522 based RFID Reader on the Arduino SPI interface.
|
||||
*
|
||||
* Warning: This may not work! Multiple devices at one SPI are difficult and cause many trouble!! Engineering skill
|
||||
* and knowledge are required!
|
||||
*
|
||||
* @license Released into the public domain.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS 1 SDA(SS) ** custom, take a unused pin, only HIGH/LOW required **
|
||||
* SPI SS 2 SDA(SS) ** custom, take a unused pin, only HIGH/LOW required **
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_1_PIN 10 // Configurable, take a unused pin, only HIGH/LOW required, must be different to SS 2
|
||||
#define SS_2_PIN 8 // Configurable, take a unused pin, only HIGH/LOW required, must be different to SS 1
|
||||
|
||||
#define NR_OF_READERS 2
|
||||
|
||||
byte ssPins[] = {SS_1_PIN, SS_2_PIN};
|
||||
|
||||
MFRC522 mfrc522[NR_OF_READERS]; // Create MFRC522 instance.
|
||||
|
||||
/**
|
||||
* Initialize.
|
||||
*/
|
||||
void setup() {
|
||||
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
|
||||
SPI.begin(); // Init SPI bus
|
||||
|
||||
for (uint8_t reader = 0; reader < NR_OF_READERS; reader++) {
|
||||
mfrc522[reader].PCD_Init(ssPins[reader], RST_PIN); // Init each MFRC522 card
|
||||
Serial.print(F("Reader "));
|
||||
Serial.print(reader);
|
||||
Serial.print(F(": "));
|
||||
mfrc522[reader].PCD_DumpVersionToSerial();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Main loop.
|
||||
*/
|
||||
void loop() {
|
||||
|
||||
for (uint8_t reader = 0; reader < NR_OF_READERS; reader++) {
|
||||
// Look for new cards
|
||||
|
||||
if (mfrc522[reader].PICC_IsNewCardPresent() && mfrc522[reader].PICC_ReadCardSerial()) {
|
||||
Serial.print(F("Reader "));
|
||||
Serial.print(reader);
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F(": Card UID:"));
|
||||
dump_byte_array(mfrc522[reader].uid.uidByte, mfrc522[reader].uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = mfrc522[reader].PICC_GetType(mfrc522[reader].uid.sak);
|
||||
Serial.println(mfrc522[reader].PICC_GetTypeName(piccType));
|
||||
|
||||
// Halt PICC
|
||||
mfrc522[reader].PICC_HaltA();
|
||||
// Stop encryption on PCD
|
||||
mfrc522[reader].PCD_StopCrypto1();
|
||||
} //if (mfrc522[reader].PICC_IsNewC
|
||||
} //for(uint8_t reader
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper routine to dump a byte array as hex values to Serial.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* Example sketch/program to test your firmware.
|
||||
* --------------------------------------------------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
|
||||
*
|
||||
* This example test the firmware of your MFRC522 reader module, only known version can be checked. If the test passed
|
||||
* it do not mean that your module is faultless! Some modules have bad or broken antennas or the PICC is broken.
|
||||
*
|
||||
* @author Rotzbua
|
||||
* @license Released into the public domain.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
/**
|
||||
* Check firmware only once at startup
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 module
|
||||
|
||||
Serial.println(F("*****************************"));
|
||||
Serial.println(F("MFRC522 Digital self test"));
|
||||
Serial.println(F("*****************************"));
|
||||
mfrc522.PCD_DumpVersionToSerial(); // Show version of PCD - MFRC522 Card Reader
|
||||
Serial.println(F("-----------------------------"));
|
||||
Serial.println(F("Only known versions supported"));
|
||||
Serial.println(F("-----------------------------"));
|
||||
Serial.println(F("Performing test..."));
|
||||
bool result = mfrc522.PCD_PerformSelfTest(); // perform the test
|
||||
Serial.println(F("-----------------------------"));
|
||||
Serial.print(F("Result: "));
|
||||
if (result)
|
||||
Serial.println(F("OK"));
|
||||
else
|
||||
Serial.println(F("DEFECT or UNKNOWN"));
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
void loop() {} // nothing to do
|
||||
@@ -0,0 +1,158 @@
|
||||
/*
|
||||
* ----------------------------------------------------------------------------
|
||||
* This is a MFRC522 library example; see https://github.com/miguelbalboa/rfid
|
||||
* for further details and other examples.
|
||||
*
|
||||
* NOTE: The library file MFRC522.h has a lot of useful info. Please read it.
|
||||
*
|
||||
* Released into the public domain.
|
||||
* ----------------------------------------------------------------------------
|
||||
* Example sketch/program which will try the most used default keys listed in
|
||||
* https://code.google.com/p/mfcuk/wiki/MifareClassicDefaultKeys to dump the
|
||||
* block 0 of a MIFARE RFID card using a RFID-RC522 reader.
|
||||
*
|
||||
* Typical pin layout used:
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
|
||||
|
||||
// Number of known default keys (hard-coded)
|
||||
// NOTE: Synchronize the NR_KNOWN_KEYS define with the defaultKeys[] array
|
||||
#define NR_KNOWN_KEYS 8
|
||||
// Known keys, see: https://code.google.com/p/mfcuk/wiki/MifareClassicDefaultKeys
|
||||
byte knownKeys[NR_KNOWN_KEYS][MFRC522::MF_KEY_SIZE] = {
|
||||
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, // FF FF FF FF FF FF = factory default
|
||||
{0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5}, // A0 A1 A2 A3 A4 A5
|
||||
{0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5}, // B0 B1 B2 B3 B4 B5
|
||||
{0x4d, 0x3a, 0x99, 0xc3, 0x51, 0xdd}, // 4D 3A 99 C3 51 DD
|
||||
{0x1a, 0x98, 0x2c, 0x7e, 0x45, 0x9a}, // 1A 98 2C 7E 45 9A
|
||||
{0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7}, // D3 F7 D3 F7 D3 F7
|
||||
{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}, // AA BB CC DD EE FF
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // 00 00 00 00 00 00
|
||||
};
|
||||
|
||||
/*
|
||||
* Initialize.
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
Serial.println(F("Try the most used default keys to print block 0 of a MIFARE PICC."));
|
||||
}
|
||||
|
||||
/*
|
||||
* Helper routine to dump a byte array as hex values to Serial.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Try using the PICC (the tag/card) with the given key to access block 0.
|
||||
* On success, it will show the key details, and dump the block data on Serial.
|
||||
*
|
||||
* @return true when the given key worked, false otherwise.
|
||||
*/
|
||||
bool try_key(MFRC522::MIFARE_Key *key)
|
||||
{
|
||||
bool result = false;
|
||||
byte buffer[18];
|
||||
byte block = 0;
|
||||
MFRC522::StatusCode status;
|
||||
|
||||
// Serial.println(F("Authenticating using key 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 false;
|
||||
}
|
||||
|
||||
// Read block
|
||||
byte byteCount = sizeof(buffer);
|
||||
status = mfrc522.MIFARE_Read(block, buffer, &byteCount);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
// Serial.print(F("MIFARE_Read() failed: "));
|
||||
// Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
}
|
||||
else {
|
||||
// Successful read
|
||||
result = true;
|
||||
Serial.print(F("Success with key:"));
|
||||
dump_byte_array((*key).keyByte, MFRC522::MF_KEY_SIZE);
|
||||
Serial.println();
|
||||
// Dump block data
|
||||
Serial.print(F("Block ")); Serial.print(block); Serial.print(F(":"));
|
||||
dump_byte_array(buffer, 16);
|
||||
Serial.println();
|
||||
}
|
||||
Serial.println();
|
||||
|
||||
mfrc522.PICC_HaltA(); // Halt PICC
|
||||
mfrc522.PCD_StopCrypto1(); // Stop encryption on PCD
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
* Main loop.
|
||||
*/
|
||||
void loop() {
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent())
|
||||
return;
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial())
|
||||
return;
|
||||
|
||||
// Show some details of the PICC (that is: the tag/card)
|
||||
Serial.print(F("Card UID:"));
|
||||
dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
|
||||
Serial.println();
|
||||
Serial.print(F("PICC type: "));
|
||||
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
Serial.println(mfrc522.PICC_GetTypeName(piccType));
|
||||
|
||||
// Try the known default keys
|
||||
MFRC522::MIFARE_Key key;
|
||||
for (byte k = 0; k < NR_KNOWN_KEYS; k++) {
|
||||
// Copy the known key into the MIFARE_Key structure
|
||||
for (byte i = 0; i < MFRC522::MF_KEY_SIZE; i++) {
|
||||
key.keyByte[i] = knownKeys[k][i];
|
||||
}
|
||||
// Try the key
|
||||
if (try_key(&key)) {
|
||||
// Found and reported on the key and block,
|
||||
// no need to try other keys for this PICC
|
||||
break;
|
||||
}
|
||||
|
||||
// http://arduino.stackexchange.com/a/14316
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent())
|
||||
break;
|
||||
if ( ! mfrc522.PICC_ReadCardSerial())
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
/*
|
||||
* Initial Author: ryand1011 (https://github.com/ryand1011)
|
||||
*
|
||||
* Reads data written by a program such as "rfid_write_personal_data.ino"
|
||||
*
|
||||
* See: https://github.com/miguelbalboa/rfid/tree/master/examples/rfid_write_personal_data
|
||||
*
|
||||
* Uses MIFARE RFID card using RFID-RC522 reader
|
||||
* Uses MFRC522 - Library
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
//*****************************************************************************************//
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
Serial.println(F("Read personal data on a MIFARE PICC:")); //shows in serial that it is ready to read
|
||||
}
|
||||
|
||||
//*****************************************************************************************//
|
||||
void loop() {
|
||||
|
||||
// Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
|
||||
MFRC522::MIFARE_Key key;
|
||||
for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;
|
||||
|
||||
//some variables we need
|
||||
byte block;
|
||||
byte len;
|
||||
MFRC522::StatusCode status;
|
||||
|
||||
//-------------------------------------------
|
||||
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial()) {
|
||||
return;
|
||||
}
|
||||
|
||||
Serial.println(F("**Card Detected:**"));
|
||||
|
||||
//-------------------------------------------
|
||||
|
||||
mfrc522.PICC_DumpDetailsToSerial(&(mfrc522.uid)); //dump some details about the card
|
||||
|
||||
//mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); //uncomment this to see all blocks in hex
|
||||
|
||||
//-------------------------------------------
|
||||
|
||||
Serial.print(F("Name: "));
|
||||
|
||||
byte buffer1[18];
|
||||
|
||||
block = 4;
|
||||
len = 18;
|
||||
|
||||
//------------------------------------------- GET FIRST NAME
|
||||
status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 4, &key, &(mfrc522.uid)); //line 834 of MFRC522.cpp file
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("Authentication failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
|
||||
status = mfrc522.MIFARE_Read(block, buffer1, &len);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("Reading failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
|
||||
//PRINT FIRST NAME
|
||||
for (uint8_t i = 0; i < 16; i++)
|
||||
{
|
||||
if (buffer1[i] != 32)
|
||||
{
|
||||
Serial.write(buffer1[i]);
|
||||
}
|
||||
}
|
||||
Serial.print(" ");
|
||||
|
||||
//---------------------------------------- GET LAST NAME
|
||||
|
||||
byte buffer2[18];
|
||||
block = 1;
|
||||
|
||||
status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 1, &key, &(mfrc522.uid)); //line 834
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("Authentication failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
|
||||
status = mfrc522.MIFARE_Read(block, buffer2, &len);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("Reading failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
|
||||
//PRINT LAST NAME
|
||||
for (uint8_t i = 0; i < 16; i++) {
|
||||
Serial.write(buffer2[i] );
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------
|
||||
|
||||
Serial.println(F("\n**End Reading**\n"));
|
||||
|
||||
delay(1000); //change value if you want to read cards faster
|
||||
|
||||
mfrc522.PICC_HaltA();
|
||||
mfrc522.PCD_StopCrypto1();
|
||||
}
|
||||
//*****************************************************************************************//
|
||||
@@ -0,0 +1,156 @@
|
||||
/*
|
||||
* Write personal data of a MIFARE RFID card using a RFID-RC522 reader
|
||||
* Uses MFRC522 - Library to use ARDUINO RFID MODULE KIT 13.56 MHZ WITH TAGS SPI W AND R BY COOQROBOT.
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* MFRC522 Arduino Arduino Arduino Arduino Arduino
|
||||
* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
|
||||
* Signal Pin Pin Pin Pin Pin Pin
|
||||
* -----------------------------------------------------------------------------------------
|
||||
* RST/Reset RST 9 5 D9 RESET/ICSP-5 RST
|
||||
* SPI SS SDA(SS) 10 53 D10 10 10
|
||||
* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16
|
||||
* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14
|
||||
* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15
|
||||
*
|
||||
* Hardware required:
|
||||
* Arduino
|
||||
* PCD (Proximity Coupling Device): NXP MFRC522 Contactless Reader IC
|
||||
* PICC (Proximity Integrated Circuit Card): A card or tag using the ISO 14443A interface, eg Mifare or NTAG203.
|
||||
* The reader can be found on eBay for around 5 dollars. Search for "mf-rc522" on ebay.com.
|
||||
*/
|
||||
|
||||
#include <SPI.h>
|
||||
#include <MFRC522.h>
|
||||
|
||||
#define RST_PIN 9 // Configurable, see typical pin layout above
|
||||
#define SS_PIN 10 // Configurable, see typical pin layout above
|
||||
|
||||
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
|
||||
|
||||
void setup() {
|
||||
Serial.begin(9600); // Initialize serial communications with the PC
|
||||
SPI.begin(); // Init SPI bus
|
||||
mfrc522.PCD_Init(); // Init MFRC522 card
|
||||
Serial.println(F("Write personal data on a MIFARE PICC "));
|
||||
}
|
||||
|
||||
void loop() {
|
||||
|
||||
// Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
|
||||
MFRC522::MIFARE_Key key;
|
||||
for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;
|
||||
|
||||
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
|
||||
if ( ! mfrc522.PICC_IsNewCardPresent()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Select one of the cards
|
||||
if ( ! mfrc522.PICC_ReadCardSerial()) {
|
||||
return;
|
||||
}
|
||||
|
||||
Serial.print(F("Card UID:")); //Dump 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.print(F(" PICC type: ")); // Dump PICC type
|
||||
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
|
||||
Serial.println(mfrc522.PICC_GetTypeName(piccType));
|
||||
|
||||
byte buffer[34];
|
||||
byte block;
|
||||
MFRC522::StatusCode status;
|
||||
byte len;
|
||||
|
||||
Serial.setTimeout(20000L) ; // wait until 20 seconds for input from serial
|
||||
// Ask personal data: Family name
|
||||
Serial.println(F("Type Family name, ending with #"));
|
||||
len = Serial.readBytesUntil('#', (char *) buffer, 30) ; // read family name from serial
|
||||
for (byte i = len; i < 30; i++) buffer[i] = ' '; // pad with spaces
|
||||
|
||||
block = 1;
|
||||
//Serial.println(F("Authenticating using key 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() success: "));
|
||||
|
||||
block = 2;
|
||||
//Serial.println(F("Authenticating using key 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;
|
||||
}
|
||||
|
||||
// Write block
|
||||
status = mfrc522.MIFARE_Write(block, &buffer[16], 16);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Write() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
else Serial.println(F("MIFARE_Write() success: "));
|
||||
|
||||
// Ask personal data: First name
|
||||
Serial.println(F("Type First name, ending with #"));
|
||||
len = Serial.readBytesUntil('#', (char *) buffer, 20) ; // read first name from serial
|
||||
for (byte i = len; i < 20; i++) buffer[i] = ' '; // pad with spaces
|
||||
|
||||
block = 4;
|
||||
//Serial.println(F("Authenticating using key 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;
|
||||
}
|
||||
|
||||
// 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() success: "));
|
||||
|
||||
block = 5;
|
||||
//Serial.println(F("Authenticating using key 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;
|
||||
}
|
||||
|
||||
// Write block
|
||||
status = mfrc522.MIFARE_Write(block, &buffer[16], 16);
|
||||
if (status != MFRC522::STATUS_OK) {
|
||||
Serial.print(F("MIFARE_Write() failed: "));
|
||||
Serial.println(mfrc522.GetStatusCodeName(status));
|
||||
return;
|
||||
}
|
||||
else Serial.println(F("MIFARE_Write() success: "));
|
||||
|
||||
|
||||
Serial.println(" ");
|
||||
mfrc522.PICC_HaltA(); // Halt PICC
|
||||
mfrc522.PCD_StopCrypto1(); // Stop encryption on PCD
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user