/*

-----------------------------------------------------------------------------------

* Pin layout should be as follows:

* Signal Pin Pin Pin Pin
* Arduino Uno Arduino Mega MFRC522 board Micro SD Card
*
---------------------------------------------------------------------------------
* Reset 9 5 RST
* SPI SS 10 53 SDA
* SPI MOSI 11 51 MOSI MOSI
* SPI MISO 12 50 MISO MISO
* SPI SCK 13 52 SCK SCK
* SPI SS 2 4 CS
* Power 3.3V 5V
* Buzzer 5
* LED Red 6
* LED Green 7
*/

#include <SPI.h>
#include <MFRC522.h>
#include <SdFat.h>

#define SS_PIN 8
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.

SdFat sd;

int CS_pin = 4;

int buzzPin = 5;
int redPin = 6;
int greenPin = 7;

void setup() {
Serial.begin(9600); // Initialize serial communications with the PC

// Disable SD Card
pinMode(CS_pin, OUTPUT);
digitalWrite(CS_pin, HIGH);

// Disable RFID
pinMode(SS_PIN, OUTPUT);
// digitalWrite(SS_PIN, HIGH);

SPI.begin(); // Init SPI bus

mfrc522.PCD_Init(); // Init MFRC522 card
//Serial.println("Scan a MIFARE Classic PICC to demonstrate Value
Blocks.");

Serial.println("Initializing Card");

if (!sd.begin(CS_pin)) {
Serial.println("Card Failed");
return;
 }
Serial.println("Card Ready");

pinMode(buzzPin, OUTPUT);
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);

digitalWrite(redPin, LOW);
digitalWrite(greenPin, LOW);

// Enable RFID
// digitalWrite(SS_PIN, LOW);

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;

}
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}

// Select one of the cards

if ( ! mfrc522.PICC_ReadCardSerial()) {
return;
}
// Now a card is selected. The UID and SAK is in mfrc522.uid.

String UIDString = "";

// Dump UID
Serial.print("Card UID:");
for (byte i = 0; i < mfrc522.uid.size; i++) {
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
UIDString = UIDString + String(mfrc522.uid.uidByte[i] < 0x10 ? " 0"
: " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
UIDString = UIDString + String(mfrc522.uid.uidByte[i], HEX);
}
Serial.println();

// Dump PICC type

byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
Serial.print("PICC type: ");
Serial.println(mfrc522.PICC_GetTypeName(piccType));
if ( piccType != MFRC522::PICC_TYPE_MIFARE_MINI
&& piccType != MFRC522::PICC_TYPE_MIFARE_1K
&& piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
//Serial.println("This sample only works with MIFARE Classic
cards.");
 return;
}

// In this sample we use the second sector (ie block 4-7). the first sector
is = 0
// scegliere settore di lettura da 0 = primo settore
byte sector = 1;
// block sector 0-3(sector0) 4-7(sector1) 8-11(sector2)
// blocchi di scrittura da 0-3(sector0) 4-7(sector1) 8-11(sector2)
byte valueBlockA = 4;
byte valueBlockB = 5;
byte valueBlockC = 6;
byte trailerBlock = 7;
byte status;
// Authenticate using key A.
// avvio l'autentificazione A
//Serial.println("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("PCD_Authenticate() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}
// Authenticate using key B.
// avvio l'autentificazione B
//Serial.println("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("PCD_Authenticate() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}

// Serial.println("Read block A(4) : the first of the sector TWO");

byte buffer[18];
byte size = sizeof(buffer);
// change this: valueBlockA , for read anather block
// cambiate valueBlockA per leggere un altro blocco
status = mfrc522.MIFARE_Read(valueBlockA, buffer, &size);

//byte value1Block[] = { 1,2,3,4, 5,6,7,8, 9,10,255,12, 13,14,15,16,

valueBlockA,~valueBlockA,valueBlockA,~valueBlockA };

if (
buffer[0] == 123 &&
buffer[1] == 225 &&
buffer[2] == 3 &&
buffer[3] == 4 &&
buffer[4] == 200 &&
buffer[5] == 6 &&
buffer[6] == 7 &&
buffer[7] == 8 &&
buffer[8] == 9 &&
buffer[9] == 10 &&
buffer[10] == 255 &&
buffer[11] == 12 &&
buffer[12] == 13 &&
buffer[13] == 14 &&
buffer[14] == 15 &&
buffer[15] == 50
){

// sel a scrittura � uguale alla lettura allora e stato un successo !!

Serial.println("The Card is GOOD !!");
Serial.println();

// Disable RFID
digitalWrite(SS_PIN, HIGH);

//Enable SD Card
digitalWrite(CS_pin, LOW);

File dataFile = sd.open("log.txt", FILE_WRITE);

if (dataFile) {
dataFile.println("E N T R Y ");
dataFile.println(UIDString);
dataFile.println();
dataFile.close();
Serial.println("E N T R Y ");
Serial.println(UIDString);
Serial.println();
}
else {
Serial.println("Couldn't Access File");
}

// Disable SD Card
digitalWrite(CS_pin, HIGH);

//Enable RFID
digitalWrite(SS_PIN, LOW);

digitalWrite(greenPin, HIGH);
digitalWrite(buzzPin, HIGH);
delay(250);
digitalWrite(buzzPin, LOW);
delay(150);
digitalWrite(buzzPin, HIGH);
delay(250);
digitalWrite(buzzPin, LOW);
digitalWrite(greenPin, LOW);
delay(100);

}else{

// scrittura Fallita
Serial.println("The Card is BAD !!!");
Serial.println();
 // Disable RFID
digitalWrite(SS_PIN, HIGH);

//Enable SD Card
digitalWrite(CS_pin, LOW);

File dataFile = sd.open("log.txt", FILE_WRITE);

if (dataFile) {
dataFile.println("ATTEMPT OF ENTRY !!! ");
dataFile.println(UIDString);
dataFile.println();
dataFile.close();
Serial.println("ATTEMPT OF ENTRY !!! ");
Serial.println(UIDString);
Serial.println();
}
else {
Serial.println("Couldn't Access File");
}

// Disable SD Card
digitalWrite(CS_pin, HIGH);

//Enable RFID
digitalWrite(SS_PIN, LOW);

digitalWrite(redPin, HIGH);
digitalWrite(buzzPin, HIGH);
delay(500);
digitalWrite(buzzPin, LOW);
digitalWrite(redPin, LOW);
delay(100);

// risponde successo
//Serial.println(mfrc522.GetStatusCodeName(status));

// Dump the result

//mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key,
sector);

// Halt PICC
mfrc522.PICC_HaltA();

// Stop encryption on PCD

mfrc522.PCD_StopCrypto1();

/////////////////////////////
#include <SPI.h>
#include <Wire.h>
#include <MFRC522.h>
#include <LiquidCrystal_I2C.h>
#include <SdFat.h>

#define MFRC_RST_PIN 9
#define MFRC_SS_PIN 10
#define SD_SS_PIN 8

#define STATE_STARTUP 0
#define STATE_STARTUP_ERROR 1
#define STATE_STARTING 2
#define STATE_WAITING 3
#define STATE_SCAN_INVALID 4
#define STATE_SCAN_VALID 5
#define STATE_SCAN_MASTER 6
#define STATE_ADDED_CARD 7
#define STATE_REMOVED_CARD 8

#define REDPIN 6
#define GREENPIN 7
#define RELAYPIN 5

const int cardSize = 4;

byte masterCard[cardSize] = {29,156,78,37};
byte readCard[cardSize] = {0,0,0,0};

// Create MFRC522 instance

MFRC522 mfrc522(MFRC_SS_PIN, MFRC_RST_PIN);
// Set the LCD I2C address
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

SdFat sd;

byte currentState = STATE_STARTUP;

unsigned long LastStateChangeTime;
unsigned long StateWaitTime;

char cardFile[] = "cards.txt";

char cardTempFile[] = "cardsTemp.txt";

//---------------------------------------------------------------------------------
---
void PrintCard(byte printCard[cardSize])
{
int index;

Serial.print("Card - ");
for(index = 0; index < 4; index++)
{
if (index > 0)
{
Serial.print(",");
}
Serial.print(printCard[index]);
}
Serial.println(" ");
}
//---------------------------------------------------------------------------------
---
boolean findCard()
{
byte currentCard[cardSize];
char text[10];
char c1;
int index;
int value;

//Serial.print("find ");
//PrintCard(readCard);

// open input file

ifstream readStr(cardFile);

// check for open error

if (!readStr.is_open())
{
return false;
}

index = 0;
// read until input fails
while (!readStr.eof())
{
readStr >> value >> c1;

if (readStr.fail())
{
break;
}

currentCard[index] = value;

index++;
if (index > 3)
{
//Serial.print("file read ");
//PrintCard(currentCard);
if ((memcmp(currentCard, readCard, 4)) == 0)
{
return true;
}
index = 0;
}
}

return false;
}

//---------------------------------------------------------------------------------
---
void addCard()
{
int index;
SdFile writeFile;

//Serial.print("add ");
 //PrintCard(readCard);
if (writeFile.open(cardFile, O_RDWR | O_CREAT | O_AT_END))
{
for(index = 0; index < 4; index++)
{
writeFile.print(readCard[index]);
writeFile.print(",");
}
writeFile.close();
}
return;
}

//---------------------------------------------------------------------------------
---
void removeCard()
{
byte currentCard[cardSize];
char text[10];
char c1;
int readIndex, writeIndex;
int value;
SdFile writeFile;

//Serial.print("remove ");
//PrintCard(readCard);

// open input file

ifstream readStr(cardFile);

// check for open error

if (!readStr.is_open())
{
return;
}

if (writeFile.open(cardTempFile, O_RDWR | O_CREAT | O_AT_END))

{
readIndex = 0;

while (!readStr.eof())
{
readStr >> value >> c1;

if (readStr.fail())
{
break;
}

currentCard[readIndex] = value;

readIndex++;
if (readIndex > 3)
{
//Serial.print("file write ");
//PrintCard(currentCard);
if (!((memcmp(currentCard, readCard, 4)) == 0))
{
for (writeIndex = 0; writeIndex < 4; writeIndex++)
 {
writeFile.print(currentCard[writeIndex]);
writeFile.print(",");
}
writeFile.close();
}
}
readIndex = 0;
}
}

sd.remove(cardFile);
sd.rename(cardTempFile, cardFile);

return;
}

//---------------------------------------------------------------------------------
---
int readCardState()
{
int index;

for(index = 0; index < 4; index++)

{
readCard[index] = mfrc522.uid.uidByte[index];
}
//Serial.print("State ");
//PrintCard();

//Check Master Card

if ((memcmp(readCard, masterCard, 4)) == 0)
{
return STATE_SCAN_MASTER;
}

if (findCard() == true)
{
return STATE_SCAN_VALID;
}

return STATE_SCAN_INVALID;
}

//---------------------------------------------------------------------------------
---
void DisplayInfo(char *Line1Str, char *Line2Str, int RedPinState, int
GreenPinState)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(Line1Str);
lcd.setCursor(0,1);
lcd.print(Line2Str);
digitalWrite(REDPIN, RedPinState);
digitalWrite(GREENPIN, GreenPinState);
}

//---------------------------------------------------------------------------------
---
void updateState(byte aState)
{
if (aState == currentState)
{
return;
}

// do state change
switch (aState)
{
case STATE_STARTING:
DisplayInfo("RFID Scanner", "Starting up", HIGH, HIGH);
StateWaitTime = 1000;
break;

case STATE_STARTUP_ERROR:
DisplayInfo("Error", "SD card", HIGH, HIGH);
StateWaitTime = 1000;
break;

case STATE_WAITING:
digitalWrite(RELAYPIN, LOW);
DisplayInfo("Waiting for Card", "to be swiped", LOW, LOW);
StateWaitTime = 1000;
break;

case STATE_SCAN_INVALID:
if (currentState == STATE_SCAN_MASTER)
{
addCard();
aState = STATE_ADDED_CARD;

DisplayInfo("Card Scanned", "Card Added", LOW, HIGH);

StateWaitTime = 2000;
}
else if (currentState == STATE_REMOVED_CARD)
{
return;
}
else
{
DisplayInfo("Card Scanned", "Invalid Card", HIGH, LOW);
StateWaitTime = 2000;
}
break;

case STATE_SCAN_VALID:
if (currentState == STATE_SCAN_MASTER)
{
removeCard();
aState = STATE_REMOVED_CARD;

DisplayInfo("Card Scanned", "Card Removed", LOW, HIGH);

StateWaitTime = 2000;
}
else if (currentState == STATE_ADDED_CARD)
{
return;
 }
else
{
digitalWrite(RELAYPIN, HIGH);
DisplayInfo("Card Scanned", "Valid Card", LOW, HIGH);
StateWaitTime = 2000;
}
break;

case STATE_SCAN_MASTER:
DisplayInfo("Master Card", "", LOW, HIGH);
StateWaitTime = 5000;
break;
}

//Serial.print("Current State - ");

//Serial.print(currentState);
//Serial.print(", New State - ");
//Serial.println(aState);

currentState = aState;
LastStateChangeTime = millis();
}

//---------------------------------------------------------------------------------
---
void setup()
{
SPI.begin(); // Init SPI Bus
mfrc522.PCD_Init(); // Init MFRC522

if (!sd.begin(SD_SS_PIN, SPI_HALF_SPEED))
{
updateState(STATE_STARTUP_ERROR);
}

lcd.begin(20,4);

LastStateChangeTime = millis();
updateState(STATE_STARTING);

pinMode(REDPIN, OUTPUT);
pinMode(GREENPIN, OUTPUT);
pinMode(RELAYPIN, OUTPUT);
digitalWrite(RELAYPIN, LOW);

Serial.begin(9600);
}

//---------------------------------------------------------------------------------
---
void loop()
{
byte cardState;

if ((currentState != STATE_WAITING) &&

(currentState != STATE_STARTUP_ERROR) &&
(StateWaitTime > 0) &&
(LastStateChangeTime + StateWaitTime < millis()))
 {
updateState(STATE_WAITING);
}

// Look for new cards

if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}

// Select one of the cards

if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}

if (currentState != STATE_STARTUP_ERROR)
{
cardState = readCardState();
updateState(cardState);
}
}