*

* Tata letak pin yang umum digunakan:

* --------------------------------------------------
----------------------------------------
* MFRC522 Arduino Arduino Arduino Arduino Arduino
* Pembaca/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro
* Pin Sinyal 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 > // Kita akan membaca dan menulis UID
PICC dari/ke EEPROM
#include < SPI.h > // Modul RC522 menggunakan protokol SPI
#include <MFRC522.h > / / Library untuk Perangkat Mifare RC522

/*
Alih-alih Relay Anda mungkin ingin menggunakan servo. Servo juga
dapat mengunci dan membuka kunci pintu
Relay akan digunakan secara default
*/

// #termasuk < Servo.h >

/*
Untuk memvisualisasikan apa yang terjadi pada perangkat keras ,
kami memerlukan beberapa led dan untuk mengontrol kunci pintu,
relai dan tombol hapus
(atau perangkat keras lainnya) Menggunakan led anoda umum ,
digitalWriting HIGH mematikan led Ingat bahwa jika Anda pergi
untuk menggunakan led katoda umum atau hanya terpisah leds ,
cukup komentar #define COMMON_ANODE,
*/

# tentukan COMMON_ANODE

# ifdef COMMON_ANODE
# tentukan LED_ON RENDAH
# tentukan LED_OFF TINGGI
# lain
# tentukan LED_ON TINGGI
# tentukan LED_OFF RENDAH
#endif _

# tentukan redLed 7 // Atur Pin Led

# tentukan hijauLed 6
# tentukan biruLed 5

# tentukan relai 4 // Setel Pin Relai

# tentukan wipeB 3 // Pin tombol untuk WipeMode

kecocokan boolean = salah; // inisialisasi kecocokan kartu ke false

boolean programMode = salah; // inisialisasi mode pemrograman ke
false
boolean replaceMaster = salah;

uint8_t suksesBaca ; // Variabel integer yang harus disimpan jika kita

berhasil Membaca dari Pembaca

byte disimpanCard [ 4]; // Menyimpan ID yang dibaca dari EEPROM

byte readCard [ 4]; // Menyimpan ID yang dipindai yang dibaca dari
Modul RFID
byte masterCard [ 4]; // Menyimpan ID kartu master yang dibaca dari
EEPROM

// Buat instance MFRC522.

# tentukan SS_PIN 10
# tentukan RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);

/////////////////////////////////////////
Mempersiapkan //////// ///////////////////////////////////////
batalkan pengaturan ( ) {
//Konfigurasi Pin Arduino
pinMode ( redLed , OUTPUT);
pinMode ( lampu hijau , OUTPUT);
pinMode ( led biru , OUTPUT);
pinMode ( wipeB , INPUT_PULLUP); // Aktifkan resistor pull up
pin
pinMode ( relai, OUTPUT);
//Hati-hati dengan perilaku rangkaian relai saat menyetel ulang atau
mendaur ulang daya Arduino Anda
digitalWrite ( relai, TINGGI); // Pastikan pintu terkunci
digitalWrite ( merahLed , LED_OFF); // Pastikan led mati
digitalWrite ( led hijau, LED_OFF ); // Pastikan led mati
digitalWrite ( led biru , LED_OFF ); // Pastikan led mati

//Konfigurasi Protokol
Serial.begin (9600 ); // Inisialisasi komunikasi serial dengan PC
SPI.mulai ( ); // MFRC522 Perangkat Keras menggunakan protokol
SPI
mfrc522.PCD_ Init( ); // Inisialisasi Perangkat Keras MFRC522

//Jika Anda mengatur Penguatan Antena ke Maks, itu akan

meningkatkan jarak baca
//mfrc522.PCD_ SetAntennaGain( mfrc522.RxGain_max);
 Serial.println ( F( "Contoh Kontrol Akses v0.1")); // Untuk tujuan
debugging
ShowReaderDetails ( ); // Tampilkan detail PCD - detail Pembaca
Kartu MFRC522

// Hapus Kode - Jika Tombol ( wipeB ) Ditekan saat setup dijalankan

(dinyalakan) itu menghapus EEPROM
if ( digitalRead ( wipeB ) == LOW) { / / ketika tombol ditekan pin
harus rendah, tombol terhubung ke ground
digitalWrite ( merahLed , LED_ON); // Led Merah tetap menyala
untuk memberi tahu pengguna bahwa kami akan menghapus
Serial.println ( F( "Tombol Hapus Ditekan"));
Serial.println ( F( "Anda memiliki 15 detik untuk Membatalkan"));
Serial.println ( F( "Ini akan menghapus semua record dan tidak
dapat dibatalkan"));
penundaan ( 15000); // Berikan waktu yang cukup kepada
pengguna untuk membatalkan operasi
if ( digitalRead ( wipeB ) == LOW) { // Jika tombol masih ditekan,
wipe EEPROM
Serial.println ( F( "Mulai Menghapus EEPROM"));
for (uint8_t x = 0; x < EEPROM.length (); x = x + 1) { //Loop end
alamat EEPROM
if ( EEPROM.read (x) == 0) { //Jika alamat EEPROM 0
// tidak melakukan apa-apa, sudah jelas, pergi ke alamat berikutnya
untuk menghemat waktu dan mengurangi penulisan ke EEPROM
}
kalau tidak {
 EEPROM.tulis (x, 0 ); // jika tidak menulis 0 untuk menghapus,
dibutuhkan 3.3mS
}
}
Serial.println ( F( "EEPROM Berhasil Dihapus"));
digitalWrite ( merahLed , LED_OFF); // visualisasikan
penghapusan yang berhasil
penundaan ( 200);
digitalWrite ( merahLed , LED_ON);
penundaan ( 200);
digitalWrite ( merahLed , LED_OFF);
penundaan ( 200);
digitalWrite ( merahLed , LED_ON);
penundaan ( 200);
digitalWrite ( merahLed , LED_OFF);
}
kalau tidak {
Serial.println ( F( "Wiping Dibatalkan")); // Tunjukkan beberapa
umpan balik bahwa tombol hapus tidak ditekan selama 15 detik
digitalWrite ( merahLed , LED_OFF);
}
}
// Periksa apakah kartu master ditentukan, jika tidak biarkan pengguna
memilih kartu master
// Ini juga berguna untuk mendefinisikan ulang Master Card
// Anda dapat menyimpan catatan EEPROM lain, cukup tulis selain
143 ke alamat EEPROM 1
// Alamat EEPROM 1 harus berisi angka ajaib yaitu '143'
if ( EEPROM.baca (1 ) ! = 143) {
Serial.println ( F( "Tidak Ada Kartu Master yang Ditentukan"));
Serial.println ( F( "Scan A PICC untuk Didefinisikan sebagai
Master Card"));
melakukan {
suksesBaca = getID ( ); // menetapkan successRead ke 1 ketika
kita dibaca dari pembaca jika tidak 0
digitalWrite ( led biru , LED_ON ); // Visualisasikan Master Card
perlu didefinisikan
penundaan ( 200);
digitalWrite ( led biru , LED_OFF );
penundaan ( 200);
}
while (! suksesBaca ); // Program tidak akan melangkah lebih jauh
saat Anda tidak berhasil membaca
for ( uint 8_t j = 0; j < 4; j++ ) { // Perulangan 4 kali
EEPROM.tulis ( 2 + j, readCard [j] ); // Tulis UID PICC yang
dipindai ke EEPROM, mulai dari alamat 3
}
EEPROM.tulis (1, 143 ); // Tulis ke EEPROM yang kita
definisikan Master Card.
Serial.println ( F( "Kartu Master Ditentukan"));
}
Serial.println ( F( "-------------------"));
 Serial.println ( F( "UID Master Card"));
for ( uint 8_t i = 0; i < 4; i ++ ) { // Membaca UID Master Card dari
EEPROM
masterCard [ i ] = EEPROM.read (2 + i ); // Tulis ke masterCard
Serial.print ( masterCard [ i ], HEX);
}
Serial.println ("");
Serial.println ( F( "-------------------"));
Serial.println ( F( "Semuanya Siap"));
Serial.println ( F( "Menunggu PICC dipindai"));
siklusLeds ( ); // Semuanya siap, mari berikan umpan balik kepada
pengguna dengan bersepeda leds
}

/////////////////////////////////////// Putaran
Utama /////// ////////////////////////////////////////
lingkaran kosong () {
melakukan {
suksesBaca = getID ( ); // menetapkan successRead ke 1 ketika kita
dibaca dari pembaca jika tidak 0
// Saat perangkat sedang digunakan jika tombol hapus ditekan selama
10 detik, inisialisasi penghapusan Kartu Master
if ( digitalRead ( wipeB ) == LOW) { / / Periksa apakah tombol
ditekan
// Visualisasikan operasi normal terganggu dengan menekan tombol
hapus Merah seperti lebih banyak Peringatan bagi pengguna
 digitalWrite ( merahLed , LED_ON); // Pastikan led mati
digitalWrite ( led hijau, LED_OFF ); // Pastikan led mati
digitalWrite ( led biru , LED_OFF ); // Pastikan led mati
// Berikan beberapa umpan balik
Serial.println ( F( "Tombol Hapus Ditekan"));
Serial.println ( F( "Kartu Master akan Dihapus! dalam 10 detik"));
penundaan ( 10000); // Tunggu 10 detik untuk melihat pengguna
masih ingin menghapus
if ( digitalRead ( wipeB ) == RENDAH) {
EEPROM.tulis (1, 0 ); // Setel Ulang Angka Ajaib.
Serial.println ( F( "Restart device untuk memprogram ulang
Master Card"));
sementara (1);
}
}
jika ( mode program ) {
siklusLeds ( ); // Mode Program berputar melalui Merah Hijau
Biru menunggu untuk membaca kartu baru
}
kalau tidak {
normalModeOn ( ); // Mode normal, LED Daya biru menyala,
yang lainnya mati
}
}
while (! suksesBaca ); //program tidak akan berjalan lebih jauh saat
Anda tidak berhasil membaca
jika ( mode program ) {
if ( isMaster ( readCard ) ) { //Ketika dalam mode program periksa
Pertama Jika kartu master dipindai lagi untuk keluar dari mode
program
Serial.println ( F( "Kartu Master Dipindai"));
Serial.println ( F( "Keluar dari Mode Program"));
Serial.println ( F( "-----------------------------"));
programMode = salah;
kembali;
}
kalau tidak {
if ( findID ( readCard ) ) { // Jika kartu yang dipindai diketahui, hapus
kartu tersebut
Serial.println ( F( "Saya tahu PICC ini, menghapus..."));
deleteID ( readCard );
Serial.println ("------------------");
Serial.println ( F( "Pindai PICC untuk ADD atau REMOVE ke
EEPROM"));
}
else { // Jika kartu yang dipindai tidak diketahui, tambahkan
Serial.println ( F( "Saya tidak tahu PICC ini, menambahkan..."));
writeID ( readCard );
Serial.println ( F( "-----------------------------"));
Serial.println ( F( "Pindai PICC untuk ADD atau REMOVE ke
EEPROM"));
}
}
}
kalau tidak {
if ( isMaster ( readCard )) { // Jika ID kartu yang dipindai cocok
dengan ID Master Card - masuk ke mode program
programMode = benar;
Serial.println ( F( "Halo Master - Masuk ke Mode Program"));
uint8_t count = EEPROM.read (0 ); // Baca Byte pertama EEPROM
yang
Serial.print ( F( "Saya punya ")); // menyimpan nomor ID di
EEPROM
Serial.print (hitungan);
Serial.print ( F( " record(s) pada EEPROM"));
Serial.println ("");
Serial.println ( F( "Pindai PICC untuk ADD atau REMOVE ke
EEPROM"));
Serial.println ( F( "Scan Master Card lagi untuk Keluar dari Mode
Program"));
Serial.println ( F( "-----------------------------"));
}
kalau tidak {
if ( findID ( readCard ) ) { // Jika tidak, lihat apakah kartu ada di
EEPROM
Serial.println ( F( "Selamat datang, Anda akan lulus"));
diberikan ( 300); // Buka kunci pintu selama 300 ms
}
else { // Jika tidak, tunjukkan bahwa ID tidak valid
 Serial.println ( F( "Kamu tidak boleh lulus"));
ditolak( );
}
}
}
}

////////////////////////////////////// / Akses
Diberikan /////// ////////////////////////////////////////
batal diberikan ( uint 16_t setDelay ) {
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
penundaan ( 100);
digitalWrite ( led biru , LED_ON ); // Pastikan LED biru menyala
penundaan ( 200);
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
penundaan ( 100);
digitalWrite ( led biru , LED_ON ); // Pastikan LED biru menyala
penundaan ( 200);
boolean a= digitalRead (relai);
digitalWrite ( relai, !a);

// Tahan LED hijau sebentar

}

/////////////////////////////////////// Akses
Ditolak / ////// ////////////////////////////////////////
batal ditolak ( ) {
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
digitalWrite ( merahLed , LED_ON); // Nyalakan LED merah
penundaan( 1000);
}

/////////////////////////////////////// Dapatkan UID

PICC ////// //////////////////////////////////////////
uint8_t getID ( ) {
// Bersiap untuk Membaca PICC
if ( ! mfrc522.PICC_IsNewCardPresent()) { //Jika PICC baru
ditempatkan ke pembaca RFID lanjutkan
kembali 0;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Karena PICC ditempatkan,
dapatkan Serial dan lanjutkan
kembali 0;
}
// Ada PICC Mifare yang memiliki perawatan UID 4 byte atau 7 byte
jika Anda menggunakan PICC 7 byte
// Saya pikir kita harus mengasumsikan setiap PICC karena mereka
memiliki 4 byte UID
// Sampai kami mendukung PICC 7 byte
Serial.println ( F( "UID PICC yang dipindai:"));
for ( uint 8_t i = 0; i < 4; i ++) { //
readCard [ i ] = mfrc522.uid.uidByte[ i ];
Serial.print ( readCard [ i ], HEX);
}
Serial.println ("");
mfrc522.PICC_ HaltA( ); // Berhenti membaca
kembali 1;
}

void ShowReaderDetails ( ) {
// Dapatkan versi perangkat lunak MFRC522
byte v = mfrc522.PCD_ ReadRegister( mfrc522.VersionReg);
Serial.print ( F( "Versi Perangkat Lunak MFRC522: 0x"));
Serial.print (v, HEX);
jika (v == 0x91)
Serial.print ( F( " = v1.0"));
lain jika (v == 0x92)
Serial.print ( F( " = v2.0"));
kalau tidak
Serial.print ( F( " (tidak diketahui),mungkin klon cina ?"));
Serial.println ("");
// Ketika 0x00 atau 0xFF dikembalikan, komunikasi mungkin gagal
if ((v == 0x00) || (v == 0xFF)) {
Serial.println ( F( "PERINGATAN: Komunikasi gagal, apakah
MFRC522 terhubung dengan benar?"));
 Serial.println ( F( "SYSTEM HALTED: Periksa koneksi."));
// Visualisasikan sistem dihentikan
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
digitalWrite ( merahLed , LED_ON); // Nyalakan LED merah
sementara (benar); // jangan melangkah lebih jauh
}
}

/////////////////////////////////////// Siklus Led (Mode

Program) /// ///////////////////////////////////////////
void siklusLeds ( ) {

digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati

penundaan ( 100);
digitalWrite ( led biru , LED_ON ); // Pastikan LED biru menyala
penundaan ( 100);
penundaan ( 200);
}

////////////////////////////////////// Mode Normal

Led / ////// ////////////////////////////////////////
batal normalModeOn () {
digitalWrite ( led biru , LED_ON ); // LED Biru AKTIF dan kartu
siap dibaca
digitalWrite ( merahLed , LED_OFF); // Pastikan LED Merah mati
 digitalWrite ( led hijau, LED_OFF ); // Pastikan LED Hijau mati
// digitalWrite ( relai, TINGGI); // Pastikan Pintu Terkunci
}

////////////////////////////////////// Membaca ID dari

EEPROM ///// ////////////////////////////////////
void readID ( nomor uint 8_t ) {
uint8_t mulai = (angka * 4 ) + 2; // Cari tahu posisi awal
for ( uint 8_t i = 0; i < 4; i ++ ) { // Loop 4 kali untuk mendapatkan 4
Bytes
storeCard [ i ] = EEPROM.read (mulai + i ); // Tetapkan nilai yang
dibaca dari EEPROM ke array
}
}

/////////////////////////////////////// Tambahkan ID ke
EEPROM ///// ///////////////////////////////////////////
void writeID ( byte a[] ) {
if ( ! findID ( a ) ) { // Sebelum kita menulis ke EEPROM, periksa
apakah kita pernah melihat kartu ini sebelumnya!
uint8_t num = EEPROM.read (0 ); // Dapatkan jumlah ruang yang
digunakan, posisi 0 menyimpan jumlah kartu ID
uint8_t mulai = ( num * 4 ) + 6; // Cari tahu di mana slot berikutnya
dimulai
bilangan ++; // Tingkatkan penghitung satu per satu
EEPROM.tulis ( 0 , angka ); // Tulis hitungan baru ke penghitung
for ( uint 8_t j = 0; j < 4; j++ ) { // Perulangan 4 kali
 EEPROM.write ( mulai + j, a[j] ); // Tulis nilai array ke EEPROM
di posisi yang tepat
}
suksesTulis ( );
Serial.println ( F( " Berhasil menambahkan catatan ID ke
EEPROM"));
}
kalau tidak {
gagalTulis ( );
Serial.println ( F( "Gagal! Ada yang salah dengan ID atau
EEPROM rusak"));
}
}

/////////////////////////////////////// Hapus ID dari

EEPROM ///// ///////////////////////////////////////////
void deleteID ( byte a[] ) {
if ( ! findID ( a ) ) { // Sebelum kita menghapus dari EEPROM,
periksa apakah kita memiliki kartu ini!
gagalTulis ( ); // Jika tidak
Serial.println ( F( "Gagal! Ada yang salah dengan ID atau
EEPROM rusak"));
}
kalau tidak {
uint8_t num = EEPROM.read (0 ); // Dapatkan jumlah ruang yang
digunakan, posisi 0 menyimpan jumlah kartu ID
uint8_t ; // Cari tahu nomor slot kartu
uint8_t mulai; // = ( angka * 4 ) + 6; // Cari tahu di mana slot
berikutnya dimulai
uint8_t ; // Berapa kali loop berulang
uint8_t j;
uint8_t count = EEPROM.read (0); // Baca Byte pertama EEPROM
yang menyimpan jumlah kartu
slot = temukanIDSLOT ( a ); // Cari tahu nomor slot kartu yang akan
dihapus
mulai = (slot * 4) + 2;
perulangan = (( num - slot) * 4);
nomor --; // Kurangi penghitung satu per satu
EEPROM.tulis ( 0 , angka ); // Tulis hitungan baru ke penghitung
for ( j = 0; j < perulangan; j++ ) { // Ulangi waktu pergantian kartu
EEPROM.tulis ( mulai + j, EEPROM . baca (mulai + 4 + j)); //
Geser nilai array ke 4 tempat sebelumnya di EEPROM
}
for ( uint 8_t k = 0; k < 4; k++ ) { // Pergeseran loop
EEPROM.tulis ( mulai + j + k, 0);
}
suksesHapus ( );
Serial.println ( F( " Berhasil menghapus catatan ID dari
EEPROM"));
}
}

/////////////////////////////////////// Periksa
Byte /////// ////////////////////////////////////////
boolean cekDua ( byte a[], byte b[] ) {
if ( a [0] != 0 ) // Pastikan ada sesuatu dalam array terlebih dahulu
cocok = benar; // Asumsikan mereka cocok pada awalnya
for ( uint 8_t k = 0; k < 4; k++ ) { // Perulangan 4 kali
if ( a [k] != b[k] ) // JIKA a != b maka set match = false, satu gagal,
semua gagal
cocok = salah;
}
if ( cocok ) { // Periksa apakah kecocokan masih benar
kembali benar; // Kembalikan benar
}
kalau tidak {
kembali salah; // Kembalikan salah
}
}

/////////////////////////////////////// Temukan
Slot /////// ////////////////////////////////////////
uint8_t findIDSLOT ( byte temukan[] ) {
uint8_t count = EEPROM.read (0 ); // Baca Byte pertama EEPROM
yang
for ( uint 8_t i = 1; i <= count; i ++ ) { // Loop sekali untuk setiap
entri EEPROM
readID ( i ); // Membaca ID dari EEPROM, disimpan di storedCard
[4]
if ( checkTwo ( find, storedCard ) ) { // Periksa untuk melihat apakah
storedCard membaca dari EEPROM
// sama dengan kartu identitas find[ ] yang diberikan
kembali saya ; // Nomor slot kartu
merusak; // Berhenti mencari, kami menemukannya
}
}
}

/////////////////////////////////////// Temukan ID Dari

EEPROM ///// ///////////////////////////////////////////
boolean findID ( byte temukan[] ) {
uint8_t count = EEPROM.read (0 ); // Baca Byte pertama EEPROM
yang
for ( uint 8_t i = 1; i <= count; i ++ ) { // Loop sekali untuk setiap
entri EEPROM
readID ( i ); // Membaca ID dari EEPROM, disimpan di storedCard
[4]
if ( checkTwo ( find, storedCard ) ) { // Periksa untuk melihat apakah
storedCard membaca dari EEPROM
kembali benar;
merusak; // Berhenti mencari, kami menemukannya
}
else { // Jika tidak, kembalikan false
}
}
kembali salah;
}
/////////////////////////////////////// Menulis Sukses ke
EEPROM ///// ///////////////////////////////////////////
// Mengedipkan LED hijau 3 kali untuk menunjukkan penulisan yang
berhasil ke EEPROM
batal suksesTulis ( ) {
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
digitalWrite ( merahLed , LED_OFF); // Pastikan LED merah mati
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau menyala
penundaan ( 200);
digitalWrite ( led hijau, LED_ON ); // Pastikan LED hijau menyala
penundaan ( 200);
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
penundaan ( 200);
digitalWrite ( led hijau, LED_ON ); // Pastikan LED hijau menyala
penundaan ( 200);
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
penundaan ( 200);
digitalWrite ( led hijau, LED_ON ); // Pastikan LED hijau menyala
penundaan ( 200);
}

/////////////////////////////////////// Gagal Menulis ke

EEPROM ///// ///////////////////////////////////////////
// Mengedipkan LED merah 3 kali untuk menunjukkan gagal menulis
ke EEPROM
batal gagalTulis ( ) {
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
digitalWrite ( merahLed , LED_OFF); // Pastikan LED merah mati
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
penundaan ( 200);
digitalWrite ( merahLed , LED_ON); // Pastikan LED merah
menyala
penundaan ( 200);
digitalWrite ( merahLed , LED_OFF); // Pastikan LED merah mati
penundaan ( 200);
digitalWrite ( merahLed , LED_ON); // Pastikan LED merah
menyala
penundaan ( 200);
digitalWrite ( merahLed , LED_OFF); // Pastikan LED merah mati
penundaan ( 200);
digitalWrite ( merahLed , LED_ON); // Pastikan LED merah
menyala
penundaan ( 200);
}

/////////////////////////////////////// Sukses Hapus UID Dari

EEPROM / /// //////////////////////////////////////////
// Mengedipkan LED biru 3 kali untuk menunjukkan penghapusan
berhasil ke EEPROM
batal suksesHapus ( ) {
digitalWrite ( led biru , LED_OFF ); // Pastikan LED biru mati
 digitalWrite ( merahLed , LED_OFF); // Pastikan LED merah mati
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau menyala
penundaan ( 200);
digitalWrite ( led hijau, LED_ON ); // Pastikan LED hijau menyala
penundaan ( 200);
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
penundaan ( 200);
digitalWrite ( led hijau, LED_ON ); // Pastikan LED hijau menyala
penundaan ( 200);
digitalWrite ( led hijau, LED_OFF ); // Pastikan LED hijau mati
penundaan ( 200);
digitalWrite ( led hijau, LED_ON ); // Pastikan LED hijau menyala
penundaan ( 200);
}

////////////////////// Periksa readCard JIKA

masterCard ////////////////////// ////////////
// Periksa untuk melihat apakah ID yang diberikan adalah kartu
program master
boolean isMaster ( uji byte [] ) {
if ( checkTwo ( tes, masterCard ) )
kembali benar;
kalau tidak
kembali salah;
}