Picproje Elektronik Sitesi

typedef enum
{
   SPI1 = 0,
   SPI2
}SPI_t;


#define SPI1_MOSI ...


void SPI_Init(SPI_t SPIx)
{
   if (SPIx == SPI1)
   {
   }
}

#ifndef MFRC522_H
#define MFRC522_H 

#include "stm32f1xx_hal.h"                  // Device header
#include "stm32f1xx_hal_gpio.h"
#include "stm32f1xx_hal_spi.h"

extern SPI_HandleTypeDef hspi1;


typedef enum {
   MI_OK = 0,
   MI_NOTAGERR,
   MI_ERR
} MFRC522_Status_t;

#define MFRC522_CS_LOW              HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);
#define MFRC522_CS_HIGH             HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);

/* MFRC522 Commands */
#define PCD_IDLE                  0x00   //NO action; Cancel the current command
#define PCD_AUTHENT                  0x0E   //Authentication Key
#define PCD_RECEIVE                  0x08   //Receive Data
#define PCD_TRANSMIT               0x04   //Transmit data
#define PCD_TRANSCEIVE               0x0C   //Transmit and receive data,
#define PCD_RESETPHASE               0x0F   //Reset
#define PCD_CALCCRC                  0x03   //CRC Calculate

/* Mifare_One card command word */
#define PICC_REQIDL                  0x26   // find the antenna area does not enter hibernation
#define PICC_REQALL                  0x52   // find all the cards antenna area
#define PICC_ANTICOLL               0x93   // anti-collision
#define PICC_SElECTTAG               0x93   // election card
#define PICC_AUTHENT1A               0x60   // authentication key A
#define PICC_AUTHENT1B               0x61   // authentication key B
#define PICC_READ                  0x30   // Read Block
#define PICC_WRITE                  0xA0   // write block
#define PICC_DECREMENT               0xC0   // debit
#define PICC_INCREMENT               0xC1   // recharge
#define PICC_RESTORE               0xC2   // transfer block data to the buffer
#define PICC_TRANSFER               0xB0   // save the data in the buffer
#define PICC_HALT                  0x50   // Sleep

/* MFRC522 Registers */
//Page 0: Command and Status
#define MFRC522_REG_RESERVED00         0x00    
#define MFRC522_REG_COMMAND            0x01    
#define MFRC522_REG_COMM_IE_N         0x02    
#define MFRC522_REG_DIV1_EN            0x03    
#define MFRC522_REG_COMM_IRQ         0x04    
#define MFRC522_REG_DIV_IRQ            0x05
#define MFRC522_REG_ERROR            0x06    
#define MFRC522_REG_STATUS1            0x07    
#define MFRC522_REG_STATUS2            0x08    
#define MFRC522_REG_FIFO_DATA         0x09
#define MFRC522_REG_FIFO_LEVEL         0x0A
#define MFRC522_REG_WATER_LEVEL         0x0B
#define MFRC522_REG_CONTROL            0x0C
#define MFRC522_REG_BIT_FRAMING         0x0D
#define MFRC522_REG_COLL            0x0E
#define MFRC522_REG_RESERVED01         0x0F
//Page 1: Command 
#define MFRC522_REG_RESERVED10         0x10
#define MFRC522_REG_MODE            0x11
#define MFRC522_REG_TX_MODE            0x12
#define MFRC522_REG_RX_MODE            0x13
#define MFRC522_REG_TX_CONTROL         0x14
#define MFRC522_REG_TX_AUTO            0x15
#define MFRC522_REG_TX_SELL            0x16
#define MFRC522_REG_RX_SELL            0x17
#define MFRC522_REG_RX_THRESHOLD      0x18
#define MFRC522_REG_DEMOD            0x19
#define MFRC522_REG_RESERVED11         0x1A
#define MFRC522_REG_RESERVED12         0x1B
#define MFRC522_REG_MIFARE            0x1C
#define MFRC522_REG_RESERVED13         0x1D
#define MFRC522_REG_RESERVED14         0x1E
#define MFRC522_REG_SERIALSPEED         0x1F
//Page 2: CFG    
#define MFRC522_REG_RESERVED20         0x20  
#define MFRC522_REG_CRC_RESULT_M      0x21
#define MFRC522_REG_CRC_RESULT_L      0x22
#define MFRC522_REG_RESERVED21         0x23
#define MFRC522_REG_MOD_WIDTH         0x24
#define MFRC522_REG_RESERVED22         0x25
#define MFRC522_REG_RF_CFG            0x26
#define MFRC522_REG_GS_N            0x27
#define MFRC522_REG_CWGS_PREG         0x28
#define MFRC522_REG__MODGS_PREG         0x29
#define MFRC522_REG_T_MODE            0x2A
#define MFRC522_REG_T_PRESCALER         0x2B
#define MFRC522_REG_T_RELOAD_H         0x2C
#define MFRC522_REG_T_RELOAD_L         0x2D
#define MFRC522_REG_T_COUNTER_VALUE_H   0x2E
#define MFRC522_REG_T_COUNTER_VALUE_L   0x2F
//Page 3:TestRegister 
#define MFRC522_REG_RESERVED30         0x30
#define MFRC522_REG_TEST_SEL1         0x31
#define MFRC522_REG_TEST_SEL2         0x32
#define MFRC522_REG_TEST_PIN_EN         0x33
#define MFRC522_REG_TEST_PIN_VALUE      0x34
#define MFRC522_REG_TEST_BUS         0x35
#define MFRC522_REG_AUTO_TEST         0x36
#define MFRC522_REG_VERSION            0x37
#define MFRC522_REG_ANALOG_TEST         0x38
#define MFRC522_REG_TEST_ADC1         0x39  
#define MFRC522_REG_TEST_ADC2         0x3A   
#define MFRC522_REG_TEST_ADC0         0x3B   
#define MFRC522_REG_RESERVED31         0x3C   
#define MFRC522_REG_RESERVED32         0x3D
#define MFRC522_REG_RESERVED33         0x3E   
#define MFRC522_REG_RESERVED34         0x3F
//Dummy byte
#define MFRC522_DUMMY               0x00

#define MFRC522_MAX_LEN               16

/**
 * Public functions
 */
/**
 * Initialize MFRC522 RFID reader
 *
 * Prepare MFRC522 to work with RFIDs
 *
 */
extern void MFRC522_Init(void);

/**
 * Check for RFID card existance
 *
 * Parameters:
 *    - uint8_t* id:
 *       Pointer to 5bytes long memory to store valid card id in.
 *       ID is valid only if card is detected, so when function returns MI_OK
 *
 * Returns MI_OK if card is detected
 */
extern MFRC522_Status_t MFRC522_Check(uint8_t* id);

/**
 * Compare 2 RFID ID's
 * Useful if you have known ID (database with allowed IDs), to compare detected card with with your ID
 *
 * Parameters:
 *    - uint8_t* CardID:
 *       Pointer to 5bytes detected card ID
 *    - uint8_t* CompareID:
 *       Pointer to 5bytes your ID
 *
 * Returns MI_OK if IDs are the same, or MI_ERR if not
 */
extern MFRC522_Status_t MFRC522_Compare(uint8_t* CardID, uint8_t* CompareID);

/**
 * Private functions
 */
extern void MFRC522_InitPins(void);
extern void MFRC522_WriteRegister(uint8_t addr, uint8_t val);
extern uint8_t MFRC522_ReadRegister(uint8_t addr);
extern void MFRC522_SetBitMask(uint8_t reg, uint8_t mask);
extern void MFRC522_ClearBitMask(uint8_t reg, uint8_t mask);
extern void MFRC522_AntennaOn(void);
extern void MFRC522_AntennaOff(void);
extern void MFRC522_Reset(void);
extern MFRC522_Status_t MFRC522_Request(uint8_t reqMode, uint8_t* TagType);
extern MFRC522_Status_t MFRC522_ToCard(uint8_t command, uint8_t* sendData, uint8_t sendLen, uint8_t* backData, uint16_t* backLen);
extern MFRC522_Status_t MFRC522_Anticoll(uint8_t* serNum);
extern void MFRC522_CalculateCRC(uint8_t* pIndata, uint8_t len, uint8_t* pOutData);
extern uint8_t MFRC522_SelectTag(uint8_t* serNum);
extern MFRC522_Status_t MFRC522_Auth(uint8_t authMode, uint8_t BlockAddr, uint8_t* Sectorkey, uint8_t* serNum);
extern MFRC522_Status_t MFRC522_Read(uint8_t blockAddr, uint8_t* recvData);
extern MFRC522_Status_t MFRC522_Write(uint8_t blockAddr, uint8_t* writeData);
extern void MFRC522_Halt(void);

#endif

#include "mfrc522.h"





void MFRC522_Init(void) {
MFRC522_CS_HIGH;


   MFRC522_Reset();

   MFRC522_WriteRegister(MFRC522_REG_T_MODE, 0x8D);
   MFRC522_WriteRegister(MFRC522_REG_T_PRESCALER, 0x3E);
   MFRC522_WriteRegister(MFRC522_REG_T_RELOAD_L, 30);           
   MFRC522_WriteRegister(MFRC522_REG_T_RELOAD_H, 0);

   /* 48dB gain */
   MFRC522_WriteRegister(MFRC522_REG_RF_CFG, 0x70);
   
   MFRC522_WriteRegister(MFRC522_REG_TX_AUTO, 0x40);
   MFRC522_WriteRegister(MFRC522_REG_MODE, 0x3D);

   MFRC522_AntennaOn();      //Open the antenna
}



 MFRC522_Status_t MFRC522_Check(uint8_t* id) {
   MFRC522_Status_t status;
   //Find cards, return card type
   status = MFRC522_Request(PICC_REQIDL, id);   
   if (status == MI_OK) {
      //Card detected
      //Anti-collision, return card serial number 4 bytes
      status = MFRC522_Anticoll(id);   
   }
   MFRC522_Halt();         //Command card into hibernation 

   return status;
}

MFRC522_Status_t MFRC522_Compare(uint8_t* CardID, uint8_t* CompareID) {
   uint8_t i;
	
	
   for (i = 0; i < 4; i++) {
		 CompareID[i]=CardID[i];
      if (CardID[i] != CompareID[i]) {
         break;
      } return MI_ERR;
		}
   
   return MI_OK;
}


   

   


void MFRC522_WriteRegister(uint8_t addr, uint8_t val) {
   //CS low
   MFRC522_CS_LOW;
   //Send address
	addr=addr << 1;
	addr=addr & 0x7E;
	
   HAL_SPI_Transmit(&hspi1,&addr,1,500);
   //Send data   
   HAL_SPI_Transmit(&hspi1,&val,1,500);
   //CS high
   MFRC522_CS_HIGH;
}

uint8_t MFRC522_ReadRegister(uint8_t addr){
   uint8_t val;
   //CS low
   MFRC522_CS_LOW;
addr=addr << 1;
	addr=addr & 0x7E;
	addr=addr | 0x80;
   HAL_SPI_Transmit(&hspi1,&addr,1,500);  
	
   HAL_SPI_Transmit(&hspi1,MFRC522_DUMMY,1,500);	
	
   HAL_SPI_Receive(&hspi1,&val,1,500);
   //CS high
   MFRC522_CS_HIGH;

   return val;   
}

void MFRC522_SetBitMask(uint8_t reg, uint8_t mask) {
   MFRC522_WriteRegister(reg, MFRC522_ReadRegister(reg) | mask);
}

void MFRC522_ClearBitMask(uint8_t reg, uint8_t mask){
   MFRC522_WriteRegister(reg, MFRC522_ReadRegister(reg) & (~mask));
} 

void MFRC522_AntennaOn(void) {
   uint8_t temp;

   temp = MFRC522_ReadRegister(MFRC522_REG_TX_CONTROL);
   if (!(temp & 0x03)) {
      MFRC522_SetBitMask(MFRC522_REG_TX_CONTROL, 0x03);
   }
}

void MFRC522_AntennaOff(void) {
   MFRC522_ClearBitMask(MFRC522_REG_TX_CONTROL, 0x03);
}

void MFRC522_Reset(void) {
   MFRC522_WriteRegister(MFRC522_REG_COMMAND, PCD_RESETPHASE);
}

MFRC522_Status_t MFRC522_Request(uint8_t reqMode, uint8_t* TagType) {
   MFRC522_Status_t status;  
   uint16_t backBits;         //The received data bits

   MFRC522_WriteRegister(MFRC522_REG_BIT_FRAMING, 0x07);      //TxLastBists = BitFramingReg[2..0]   ???

   TagType[0] = reqMode;
   status = MFRC522_ToCard(PCD_TRANSCEIVE, TagType, 1, TagType, &backBits);

   if ((status != MI_OK) || (backBits != 0x10)) {    
      status = MI_ERR;
   }

   return status;
}

MFRC522_Status_t MFRC522_ToCard(uint8_t command, uint8_t* sendData, uint8_t sendLen, uint8_t* backData, uint16_t* backLen) {
   MFRC522_Status_t status = MI_ERR;
   uint8_t irqEn = 0x00;
   uint8_t waitIRq = 0x00;
   uint8_t lastBits;
   uint8_t n;
   uint16_t i;

   switch (command) {
      case PCD_AUTHENT: {
         irqEn = 0x12;
         waitIRq = 0x10;
         break;
      }
      case PCD_TRANSCEIVE: {
         irqEn = 0x77;
         waitIRq = 0x30;
         break;
      }
      default:
         break;
   }

   MFRC522_WriteRegister(MFRC522_REG_COMM_IE_N, irqEn | 0x80);
   MFRC522_ClearBitMask(MFRC522_REG_COMM_IRQ, 0x80);
   MFRC522_SetBitMask(MFRC522_REG_FIFO_LEVEL, 0x80);

   MFRC522_WriteRegister(MFRC522_REG_COMMAND, PCD_IDLE);

   //Writing data to the FIFO
   for (i = 0; i < sendLen; i++) {   
      MFRC522_WriteRegister(MFRC522_REG_FIFO_DATA, sendData[i]);    
   }

   //Execute the command
   MFRC522_WriteRegister(MFRC522_REG_COMMAND, command);
   if (command == PCD_TRANSCEIVE) {    
      MFRC522_SetBitMask(MFRC522_REG_BIT_FRAMING, 0x80);      //StartSend=1,transmission of data starts  
   }   

   //Waiting to receive data to complete
   i = 2000;   //i according to the clock frequency adjustment, the operator M1 card maximum waiting time 25ms???
   do {
      //CommIrqReg[7..0]
      //Set1 TxIRq RxIRq IdleIRq HiAlerIRq LoAlertIRq ErrIRq TimerIRq
      n = MFRC522_ReadRegister(MFRC522_REG_COMM_IRQ);
      i--;
   } while ((i!=0) && !(n&0x01) && !(n&waitIRq));

   MFRC522_ClearBitMask(MFRC522_REG_BIT_FRAMING, 0x80);         //StartSend=0

   if (i != 0)  {
      if (!(MFRC522_ReadRegister(MFRC522_REG_ERROR) & 0x1B)) {
         status = MI_OK;
         if (n & irqEn & 0x01) {   
            status = MI_NOTAGERR;         
         }

         if (command == PCD_TRANSCEIVE) {
            n = MFRC522_ReadRegister(MFRC522_REG_FIFO_LEVEL);
            lastBits = MFRC522_ReadRegister(MFRC522_REG_CONTROL) & 0x07;
            if (lastBits) {   
               *backLen = (n - 1) * 8 + lastBits;   
            } else {   
               *backLen = n * 8;   
            }

            if (n == 0) {   
               n = 1;    
            }
            if (n > MFRC522_MAX_LEN) {   
               n = MFRC522_MAX_LEN;   
            }

            //Reading the received data in FIFO
            for (i = 0; i < n; i++) {   
               backData[i] = MFRC522_ReadRegister(MFRC522_REG_FIFO_DATA);    
            }
         }
      } else {   
         status = MI_ERR;  
      }
   }

   return status;
}

MFRC522_Status_t MFRC522_Anticoll(uint8_t* serNum) {
   MFRC522_Status_t status;
   uint8_t i;
   uint8_t serNumCheck = 0;
   uint16_t unLen;

   MFRC522_WriteRegister(MFRC522_REG_BIT_FRAMING, 0x00);      //TxLastBists = BitFramingReg[2..0]

   serNum[0] = PICC_ANTICOLL;
   serNum[1] = 0x20;
   status = MFRC522_ToCard(PCD_TRANSCEIVE, serNum, 2, serNum, &unLen);
//(uint8_t command, uint8_t* sendData, uint8_t sendLen, uint8_t* backData, uint16_t* backLen) {
   if (status == MI_OK) {
      //Check card serial number
      for (i = 0; i < 4; i++) {   
         serNumCheck ^= serNum[i];
      }
      if (serNumCheck != serNum[i]) {   
         status = MI_ERR;    
      }
   }
   return status;
} 

void MFRC522_CalculateCRC(uint8_t*  pIndata, uint8_t len, uint8_t* pOutData) {
   uint8_t i, n;

   MFRC522_ClearBitMask(MFRC522_REG_DIV_IRQ, 0x04);         //CRCIrq = 0
   MFRC522_SetBitMask(MFRC522_REG_FIFO_LEVEL, 0x80);         //Clear the FIFO pointer
   //Write_MFRC522(CommandReg, PCD_IDLE);

   //Writing data to the FIFO   
   for (i = 0; i < len; i++) {   
      MFRC522_WriteRegister(MFRC522_REG_FIFO_DATA, *(pIndata+i));   
   }
   MFRC522_WriteRegister(MFRC522_REG_COMMAND, PCD_CALCCRC);

   //Wait CRC calculation is complete
   i = 0xFF;
   do {
      n = MFRC522_ReadRegister(MFRC522_REG_DIV_IRQ);
      i--;
   } while ((i!=0) && !(n&0x04));         //CRCIrq = 1

   //Read CRC calculation result
   pOutData[0] = MFRC522_ReadRegister(MFRC522_REG_CRC_RESULT_L);
   pOutData[1] = MFRC522_ReadRegister(MFRC522_REG_CRC_RESULT_M);
}

uint8_t MFRC522_SelectTag(uint8_t* serNum) {
   uint8_t i;
   MFRC522_Status_t status;
   uint8_t size;
   uint16_t recvBits;
   uint8_t buffer[9]; 

   buffer[0] = PICC_SElECTTAG;
   buffer[1] = 0x70;
   for (i = 0; i < 5; i++) {
      buffer[i+2] = *(serNum+i);
   }
   MFRC522_CalculateCRC(buffer, 7, &buffer[7]);      //??
   status = MFRC522_ToCard(PCD_TRANSCEIVE, buffer, 9, buffer, &recvBits);

   if ((status == MI_OK) && (recvBits == 0x18)) {   
      size = buffer[0]; 
   } else {   
      size = 0;    
   }

   return size;
}

MFRC522_Status_t MFRC522_Auth(uint8_t authMode, uint8_t BlockAddr, uint8_t* Sectorkey, uint8_t* serNum) {
   MFRC522_Status_t status;
   uint16_t recvBits;
   uint8_t i;
   uint8_t buff[12]; 

   //Verify the command block address + sector + password + card serial number
   buff[0] = authMode;
   buff[1] = BlockAddr;
   for (i = 0; i < 6; i++) {    
      buff[i+2] = *(Sectorkey+i);   
   }
   for (i=0; i<4; i++) {    
      buff[i+8] = *(serNum+i);   
   }
   status = MFRC522_ToCard(PCD_AUTHENT, buff, 12, buff, &recvBits);

   if ((status != MI_OK) || (!(MFRC522_ReadRegister(MFRC522_REG_STATUS2) & 0x08))) {   
      status = MI_ERR;   
   }
   return status;
}

MFRC522_Status_t MFRC522_Read(uint8_t blockAddr, uint8_t* recvData) {
   MFRC522_Status_t status;
   uint16_t unLen;

   recvData[0] = PICC_READ;
   recvData[1] = blockAddr;
   MFRC522_CalculateCRC(recvData,2, &recvData[2]);
   status = MFRC522_ToCard(PCD_TRANSCEIVE, recvData, 4, recvData, &unLen);

   if ((status != MI_OK) || (unLen != 0x90)) {
      status = MI_ERR;
   }

   return status;
}

MFRC522_Status_t MFRC522_Write(uint8_t blockAddr, uint8_t* writeData) {
   MFRC522_Status_t status;
   uint16_t recvBits;
   uint8_t i;
   uint8_t buff[18]; 

   buff[0] = PICC_WRITE;
   buff[1] = blockAddr;
   MFRC522_CalculateCRC(buff, 2, &buff[2]);
   status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff, &recvBits);

   if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A)) {   
      status = MI_ERR;   
   }

   if (status == MI_OK) {
      //Data to the FIFO write 16Byte
      for (i = 0; i < 16; i++) {    
         buff[i] = *(writeData+i);   
      }
      MFRC522_CalculateCRC(buff, 16, &buff[16]);
      status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 18, buff, &recvBits);

      if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A)) {   
         status = MI_ERR;   
      }
   }

   return status;
}

void MFRC522_Halt(void) {
   uint16_t unLen;
   uint8_t buff[4]; 

   buff[0] = PICC_HALT;
   buff[1] = 0;
   MFRC522_CalculateCRC(buff, 2, &buff[2]);

   MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff, &unLen);
}