Interfacing RFID-RC522 Sensor dengan Wemos D1 mini

FRID-RC522 Sensor adalah contacless reader/writer yang mendukung semua varian dari MIFARE Mini, baik protokol identifikasi MIFARE 1K maupun MIFARE 4K, MIFRARE Ultralight, MIFARE DESFire EV1 dan MIFARE Plus RF. Berikut ini adalah gambar sensor yang dimaksud.

Adapun Pin Dengan Pin sebagai berikut:

Adapun Pin pada Wemos D1 mini pro adalah sebagai berikut:

Sehingga Interfacing antara RFID-RC522 dengan Wemos D1 mini pro adalah:

pin SDA ke D2
pin SCK ke D5
pin MOSI ke D7
pin MISO ke D6
pin IRQ diabaikan
pin GND ke GND
pin RST ke D4
pin VCC ke 3V3

Setelah melakukan interfacing, maka kini saatnya untuk mempersiapkan lingkungan pengembangan dengan mendownload Arduino RFID Library for MFRC522 yang dapat didownload pada link, setelah download, maka pada sketch pilih menu :

Copy dan Paste koding berikut ini:

#include "MFRC522.h"
#define RST_PIN D4  // RST-PIN ke D4
#define SS_PIN  D2  // SDA-PIN ke D2

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

void setup() {
  Serial.begin(9600); // Initialize serial communications
  while (!Serial);    // Do nothing until serial port is opened
  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 &lt; 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() {
  // 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));

  // Check for compatibility
  if (    piccType != MFRC522::PICC_TYPE_MIFARE_MINI
          &amp;&amp;  piccType != MFRC522::PICC_TYPE_MIFARE_1K
          &amp;&amp;  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,
    0x08, 0x09, 0xff, 0x0b, //  9, 10, 255, 12,
    0x0c, 0x0d, 0x0e, 0x0f  // 13, 14,  15, 16
  };
  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, &amp;key, &amp;(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(&amp;(mfrc522.uid), &amp;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, &amp;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, &amp;key, &amp;(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, &amp;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 &lt; 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:"));

  for (int sectorcount=0; sectorcount &lt; 16; sectorcount++) {
    mfrc522.PICC_DumpMifareClassicSectorToSerial(&amp;(mfrc522.uid), &amp;key, sectorcount);
    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 &lt; bufferSize; i++) {
    Serial.print(buffer[i] &lt; 0x10 ? " 0" : " ");
    Serial.print(buffer[i], HEX);
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

#include "MFRC522.h"

#define RST_PIN D4 // RST-PIN ke D4

#define SS_PIN D2 // SDA-PIN ke D2

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance

MFRC522::MIFARE_Key key;

void setup() {

Serial.begin(9600); // Initialize serial communications

while (!Serial); // Do nothing until serial port is opened

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

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

// 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,

0x08, 0x09, 0xff, 0x0b, // 9, 10, 255, 12,

0x0c, 0x0d, 0x0e, 0x0f // 13, 14, 15, 16

};

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 = ;

for (byte i = ; 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:"));

for (int sectorcount=; sectorcount < 16; sectorcount++) {

mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sectorcount);

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 = ; i < bufferSize; i++) {

Serial.print(buffer[i] < 0x10 ? " 0" : " ");

Serial.print(buffer[i], HEX);

}

Hasil pengujian:

Aktifkan serial monitor:

Scan a MIFARE Classic PICC to demonstrate read and write.
Using key (for A and B): FF FF FF FF FF FF
BEWARE: Data will be written to the PICC, in sector #1
Card UID: 46 74 1E 2B
PICC type: MIFARE 1KB
Authenticating using key A…
Current data in sector:
   1      7   00 00 00 00 00 00 FF 07 80 69 FF FF FF FF FF FF [ 0 0 1 ]
          6   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [ 0 0 0 ]
          5   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [ 0 0 0 ]
          4   01 02 03 04 05 06 07 08 08 09 FF 0B 0C 0D 0E 0F [ 0 0 0 ]

Reading data from block 4 …
Data in block 4:
01 02 03 04 05 06 07 08 08 09 FF 0B 0C 0D 0E 0F

Authenticating again using key B…
Writing data into block 4 …
01 02 03 04 05 06 07 08 08 09 FF 0B 0C 0D 0E 0F

Reading data from block 4 …
Data in block 4:
01 02 03 04 05 06 07 08 08 09 FF 0B 0C 0D 0E 0F
Checking result…
Number of bytes that match = 16
Success 🙂

Current data in sector:
   0      3   00 00 00 00 00 00 FF 07 80 69 FF FF FF FF FF FF [ 0 0 1 ]
          2   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [ 0 0 0 ]
          1   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [ 0 0 0 ]
          0   46 74 1E 2B 07 08 04 00 62 63 64 65 66 67 68 69 [ 0 0 0 ]