Arduino WiFi – ESP8266 with MFRC522

Follow me

Marv Marvelous

http://www.grafovision.sk
Follow me

 

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 Mega Nano v3 Leonardo/Micro Pro Micro
Signal Pin Pin Pin Pin Pin Pin
—————————————————————————————–
RST/Reset RST 9 5 D9 RESET/ICSP-5 RST NC
SPI SS SDA(SS) 10 53 D10 10 10 GPIO2
SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16 GPIO12
SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14 GPIO13
SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15 GPIO14

*/
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <SPI.h>
#include  <MFRC522.h>

#define RST_PIN 15 // Configurable, see typical pin layout above
#define SS_PIN 2 // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
MFRC522::MIFARE_Key key;

/**
Initialize.
*/
const char* ssid = “YYap”; //
const char* password = “1111111111”;

IPAddress ip(192, 168, 1, 111); //Node static IP
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

// Global variables
WiFiClient client;

ESP8266WebServer server(80);

const int led = 0;

void handleRoot() {
// Prepare the response. Start with the common header:
String s = “\r\n\r\n”; s += “”; s += “”; s += “CARD DATA: “; s += ”

“;
s += ““;
s += ““;
s += ”

“;
s += ”

“;
s += ““;
s += ”

\n”;
server.send(200, “text/html”, s);
}

void handleNotFound() {
digitalWrite(led, 1);
String message = “File Not Found\n\n”;
message += “URI: “;
message += server.uri();
message += “\nMethod: “;
message += (server.method() == HTTP_GET) ? “GET” : “POST”;
message += “\nArguments: “;
message += server.args();
message += “\n”;
for (uint8_t i = 0; i < server.args(); i++) {
message += ” ” + server.argName(i) + “: ” + server.arg(i) + “\n”;
}
server.send(404, “text/plain”, message);
digitalWrite(led, 0);
}

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”));

WiFi.begin(ssid, password);
WiFi.config(ip, gateway, subnet);
Serial.println(“”);

// Wait for connection
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(“.”);
}
Serial.println(“”);
Serial.print(“Connected to “);
Serial.println(ssid);
Serial.print(“IP address: “);
Serial.println(WiFi.localIP());

// if (MDNS.begin(“esp8266”)) {
// Serial.println(“MDNS responder started”);
// }

server.on(“/”, handleRoot);

server.on(“/rfidread”, []() {
// server.send(200, “text/plain”, “this works as well”);
readrfid();
});

server.on(“/rfidwrite”, []() {
// server.send(200, “text/plain”, “this works as well”);
writerfid();
handleRoot();
});

server.onNotFound(handleNotFound);

server.begin();
Serial.println(“HTTP server started”);

}

/**
Main loop.
*/
void loop() {
server.handleClient();
}

void readrfid() {

String message1 = “”;
// get URI ARG=rfidread and rfidwrite
for (uint8_t i = 0; i < server.args(); i++) {
if ( server.argName(i) == “YY”) {
message1 = server.arg(i);
}
}

// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent())
{
String s = “\r\n\r\n”; s += “”; s += “”; s += “CARD DATA: “; s += ”

“;
s += ““;
s += ““;
s += ”

“;
s += ”

“;
s += ““;
s += ”

請重新放上RFID Card “;
s += ”

\n”;
server.send(200, “text/html”, s);
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 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();

// Halt PICC
mfrc522.PICC_HaltA();
// Stop encryption on PCD
mfrc522.PCD_StopCrypto1();

char carddata[18];
memcpy(carddata, buffer, sizeof buffer);
String message2 = “File Not Found\n\n”;
message2 += “CARD DATA: “;
message2 += carddata;
// server.send(200, “text/plain”, message2);

String s = “\r\n\r\n”; s += “”; s += “”; s += “CARD DATA: “; s += ”

“;
s += ““;
s += ““;
s += ”

“;
s += ”

“;
s += ““;
s += ”

\n”;
server.send(200, “text/html”, s);

}

void writerfid() {

String message1 = ” “;
for (uint8_t i = 0; i < server.args(); i++) {
if ( server.argName(i) == “YY”) {
//char data1[] = “1123456789ABCDEF”;
message1 = server.arg(i);
}
}

if ( ! mfrc522.PICC_IsNewCardPresent())
{
String s = “\r\n\r\n”; s += “”; s += “”; s += “CARD DATA: “; s += ”

“;
s += ““;
s += ““;
s += ”

“;
s += ”

“;
s += ““;
s += ”

請重新放上RFID Card “;
s += ”

\n”;
server.send(200, “text/html”, s);
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[] = {
0x02, 0x02, 0x03, 0x04, // 1, 2, 3, 4,
0x05, 0x06, 0x07, 0x08, // 5, 6, 7, 8,
0x08, 0x09, 0xff, 0x0b, // 9, 10, 255, 12,
0x0c, 0x0d, 0x0e, 0x0f // 13, 14, 15, 16
};

// char data1[] = “1123456789ABCDEF”;

for (byte i = 0; i < 16; i++) {
// dataBlock[i]=(data1[i],HEX);
dataBlock[i] = message1[i] & 0xff;
}

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();

// 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);
}
}

Marv Marvelous

Zanechať odpoveď