API tools faq
paste
Guest User

RFID with a single comment.

a guest
Apr 9th, 2014
186
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 25.12 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. ///////////VEEL PRINTCOMMENTS VERWIJDERD, VERDER NOG STEEDS ORIGINEEL
  3. //////////////DIT PROGRAMMA NIET MEER VERANDEREN!!!!!!!
  4.  * RFID.pde
  5.  * PURCHASED FROM: (EBAY) WWW.B2CQSHOP.COM
  6.  * COMPLIATION OF COMMENTS FROM MULTIPLE SOURCES/SEARCHES ON SAME SKETCH
  7.  * Mifare1
  8.  */
  9.  
  10. // the sensor communicates using SPI, so include the library:
  11. #include <SPI.h>
  12.  
  13. #define uchar   unsigned char
  14. #define uint    unsigned int
  15. #define MAX_LEN 16
  16.  
  17. //set the pin(s)
  18. const int chipSelectPin = 3;
  19. const int NRSTPD = 5;
  20.  
  21. //MF522 command bits
  22. #define PCD_IDLE              0x00               //NO action; cancel current commands
  23. #define PCD_AUTHENT           0x0E               //verify password key
  24. #define PCD_RECEIVE           0x08               //receive data
  25. #define PCD_TRANSMIT          0x04               //send data
  26. #define PCD_TRANSCEIVE        0x0C               //send and receive data
  27. #define PCD_RESETPHASE        0x0F               //reset
  28. #define PCD_CALCCRC           0x03               //CRC check and caculation
  29.  
  30. //Mifare_One card command bits
  31. #define PICC_REQIDL           0x26               //Search the cards that not into sleep mode in the antenna area
  32. #define PICC_REQALL           0x52               //Search all the cards in the antenna area
  33. #define PICC_ANTICOLL         0x93               //prevent conflict
  34. #define PICC_SElECTTAG        0x93               //select card
  35. #define PICC_AUTHENT1A        0x60               //verify A password key
  36. #define PICC_AUTHENT1B        0x61               //verify B password key
  37. #define PICC_READ             0x30               //read
  38. #define PICC_WRITE            0xA0               //write
  39. #define PICC_DECREMENT        0xC0               //deduct value
  40. #define PICC_INCREMENT        0xC1               //charge up value
  41. #define PICC_RESTORE          0xC2               //Restore data into buffer
  42. #define PICC_TRANSFER         0xB0               //Save data into buffer
  43. #define PICC_HALT             0x50               //sleep mode
  44.  
  45.  
  46. //The statuts/error code that returns when attempted communication with MF522
  47. #define MI_OK                 0
  48. #define MI_NOTAGERR           1
  49. #define MI_ERR                2
  50.  
  51.  
  52. //------------------MFRC522 register ---------------
  53. //Page 0:Command and Status
  54. #define     Reserved00            0x00    
  55. #define     CommandReg            0x01    
  56. #define     CommIEnReg            0x02    
  57. #define     DivlEnReg             0x03    
  58. #define     CommIrqReg            0x04    
  59. #define     DivIrqReg             0x05
  60. #define     ErrorReg              0x06    
  61. #define     Status1Reg            0x07    
  62. #define     Status2Reg            0x08    
  63. #define     FIFODataReg           0x09
  64. #define     FIFOLevelReg          0x0A
  65. #define     WaterLevelReg         0x0B
  66. #define     ControlReg            0x0C
  67. #define     BitFramingReg         0x0D
  68. #define     CollReg               0x0E
  69. #define     Reserved01            0x0F
  70. //Page 1:Command    
  71. #define     Reserved10            0x10
  72. #define     ModeReg               0x11
  73. #define     TxModeReg             0x12
  74. #define     RxModeReg             0x13
  75. #define     TxControlReg          0x14
  76. #define     TxAutoReg             0x15
  77. #define     TxSelReg              0x16
  78. #define     RxSelReg              0x17
  79. #define     RxThresholdReg        0x18
  80. #define     DemodReg              0x19
  81. #define     Reserved11            0x1A
  82. #define     Reserved12            0x1B
  83. #define     MifareReg             0x1C
  84. #define     Reserved13            0x1D
  85. #define     Reserved14            0x1E
  86. #define     SerialSpeedReg        0x1F
  87. //Page 2:CFG    
  88. #define     Reserved20            0x20  
  89. #define     CRCResultRegM         0x21
  90. #define     CRCResultRegL         0x22
  91. #define     Reserved21            0x23
  92. #define     ModWidthReg           0x24
  93. #define     Reserved22            0x25
  94. #define     RFCfgReg              0x26
  95. #define     GsNReg                0x27
  96. #define     CWGsPReg              0x28
  97. #define     ModGsPReg             0x29
  98. #define     TModeReg              0x2A
  99. #define     TPrescalerReg         0x2B
  100. #define     TReloadRegH           0x2C
  101. #define     TReloadRegL           0x2D
  102. #define     TCounterValueRegH     0x2E
  103. #define     TCounterValueRegL     0x2F
  104. //Page 3:TestRegister    
  105. #define     Reserved30            0x30
  106. #define     TestSel1Reg           0x31
  107. #define     TestSel2Reg           0x32
  108. #define     TestPinEnReg          0x33
  109. #define     TestPinValueReg       0x34
  110. #define     TestBusReg            0x35
  111. #define     AutoTestReg           0x36
  112. #define     VersionReg            0x37
  113. #define     AnalogTestReg         0x38
  114. #define     TestDAC1Reg           0x39  
  115. #define     TestDAC2Reg           0x3A  
  116. #define     TestADCReg            0x3B  
  117. #define     Reserved31            0x3C  
  118. #define     Reserved32            0x3D  
  119. #define     Reserved33            0x3E  
  120. #define     Reserved34            0x3F
  121. //-----------------------------------------------
  122.  
  123. //4 bytes Serial number of card, the 5 bytes is verfiy bytes
  124. uchar serNum[5];
  125.  
  126. uchar  writeData[16]={
  127.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100};  //initialize to $100 USD
  128. uchar  moneyConsume = 18 ;  //Deduct $18 USD
  129. uchar  moneyAdd = 10 ;  //Charge up $10 USD
  130.  
  131.  
  132. //buffer 'A' password, 16 buffer, the passowrd of every buffer is 6 byte
  133. uchar sectorKeyA[16][16] = {
  134.   {
  135.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF                                }
  136.   ,
  137.   {
  138.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF                                }
  139.   ,
  140.   //when you try it again, please change it into your new password
  141.   {
  142.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF                                }
  143.   ,
  144.   {
  145.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF                                }
  146.   ,
  147. };
  148. //A 16 6Byte
  149. uchar sectorNewKeyA[16][16] = {
  150.   {
  151.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF                                }
  152.   ,
  153.   {
  154.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xff, 0x07, 0x80, 0x69, 0x19, 0x84, 0x07, 0x15, 0x76, 0x14                                }
  155.   ,
  156.   {
  157.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xff, 0x07, 0x80, 0x69, 0x19, 0x33, 0x07, 0x15, 0x34, 0x14                                }
  158.   ,//you can set another ket , such as  " 0x19, 0x84, 0x07, 0x15, 0x76, 0x14 "
  159.   //{0x19, 0x84, 0x07, 0x15, 0x76, 0x14, 0xff,0x07,0x80,0x69, 0x19,0x84,0x07,0x15,0x76,0x14},
  160.   // but when loop, please set the  sectorKeyA, the same key, so that RFID module can read the card
  161.  
  162.   {
  163.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xff, 0x07, 0x80, 0x69, 0x19, 0x33, 0x07, 0x15, 0x34, 0x14                                }
  164.   ,
  165. };
  166.  
  167.  
  168. //setup program defaults/vars..etc
  169. void setup() {                
  170.   Serial.begin(9600); // RFID pin connected to Serial RX pin at 2400bps
  171.   // start the SPI library:
  172.   SPI.begin();
  173.  
  174.   //set up chip select pin
  175.   pinMode(chipSelectPin,OUTPUT);    // Set digital pin 10 as OUTPUT to connect it to the RFID /ENABLE pin          
  176.   digitalWrite(chipSelectPin, LOW); // Activate the RFID reader
  177.   //setup the RFID RESET PIN  
  178.   pinMode(NRSTPD,OUTPUT);            // Set digital pin 10 , Not Reset and Power-down  
  179.   digitalWrite(NRSTPD, HIGH);
  180.  
  181.   //call/run/execute the RFID init() function
  182.   MFRC522_Init();  
  183. }
  184.  
  185.  
  186.  
  187. void loop(){
  188.     uchar i,tmp;
  189.     uchar status;
  190.     uchar str[MAX_LEN];
  191.     uchar RC_size;
  192.     uchar blockAddr;  //Select operation block address  0 - 63
  193.  
  194.     //Search card, return card types
  195.     status = MFRC522_Request(PICC_REQIDL, str);
  196.     if (status == MI_OK){
  197.         Serial.println("CARD DETECTED IN PROXIMITY....");
  198.         Serial.print("CARD TYPE: ");
  199.         Serial.print(str[0],DEC);
  200.         Serial.print(" / ");
  201.         Serial.print("STATUS CODE: ");
  202.         Serial.println(str[1],DEC);
  203.         Serial.println(" ");
  204.         delay(500);
  205.     }
  206.  
  207.     //Prevent conflict, return the 4 bytes Serial number of the card
  208.     status = MFRC522_Anticoll(str);
  209.     memcpy(serNum, str, 5);
  210.     if (status == MI_OK){
  211.         Serial.print("THE TARGET CARD IS:  ");
  212.         Serial.print(serNum[0],BIN);
  213.         Serial.print(" , ");
  214.         Serial.print(serNum[1],BIN);
  215.         Serial.print(" , ");
  216.         Serial.print(serNum[2],BIN);
  217.         Serial.print(" , ");
  218.         Serial.print(serNum[3],BIN);
  219.         Serial.print(" , ");
  220.         Serial.print(serNum[4],BIN);
  221.         Serial.println(" ");
  222.  
  223.         //get first initial number  to check against.. (should use full number for legit checking)
  224.         Serial.print(serNum[0],DEC);
  225.         Serial.print(" , ");
  226.         Serial.println(" ");
  227.  
  228.         //serial number check
  229.         if(serNum[0] == 50) {
  230.             Serial.print("BLUE CARD");
  231.             Serial.print("   S/N: (");
  232.             Serial.print(serNum[0],DEC);
  233.             Serial.print(serNum[1],DEC);
  234.             Serial.print(serNum[2],DEC);
  235.             Serial.print(serNum[3],DEC);
  236.             Serial.print(serNum[4],DEC);
  237.             Serial.println(")");
  238.         }else if(serNum[0] == 255) {
  239.             Serial.print("WHITE CARD");
  240.             Serial.print("   S/N: (");
  241.             Serial.print(serNum[0],DEC);
  242.             Serial.print(serNum[1],DEC);
  243.             Serial.print(serNum[2],DEC);
  244.             Serial.print(serNum[3],DEC);
  245.             Serial.print(serNum[4],DEC);
  246.             Serial.println(")");
  247.         }
  248.     }
  249.  
  250.     RC_size = MFRC522_SelectTag(serNum);
  251.     if (RC_size != 0){
  252.         Serial.print("Space on card is :   ");
  253.         Serial.print(RC_size,DEC);
  254.         Serial.println("K ");
  255.         Serial.println(" ");
  256.     }
  257.  
  258.     //test (junk) card reads testing out what these functions do/return?
  259.     /*
  260.     uchar tmp1;
  261.     uchar tmp2;
  262.     tmp1 = Read_MFRC522(Status1Reg);
  263.     tmp2 = Read_MFRC522(Status2Reg);
  264.     Serial.print("DATA CHECK: ");
  265.     Serial.print(tmp1,HEX);
  266.     Serial.println(" / ");
  267.     Serial.println(tmp2,HEX);
  268.     Serial.println("");
  269.     */
  270.  
  271.     //Don't initialise the card with 100$ every time!
  272.     /*  
  273.     blockAddr = 11;     //11       
  274.     status = MFRC522_Auth(PICC_AUTHENT1A, blockAddr, sectorKeyA[blockAddr/4], serNum);  //??
  275.  
  276.     if (status == MI_OK){  
  277.         status = MFRC522_Write(blockAddr, sectorNewKeyA[blockAddr/4]);
  278.         Serial.print("set the new card password, and can modify the data of the Sector ");
  279.         Serial.print(blockAddr/4,DEC);
  280.         Serial.println(" : ");
  281.  
  282.         for (i=0; i<6; i++){
  283.             Serial.print(sectorNewKeyA[blockAddr/4][i],HEX);
  284.             Serial.print(" , ");
  285.         }
  286.         Serial.println(" ");
  287.  
  288.         //no clue how this relates to password? and 'auto' $100 on cards?
  289.         //(where is that set or stored? initially?)
  290.         blockAddr = blockAddr - 3 ;
  291.         status = MFRC522_Write(blockAddr, writeData);
  292.         if(status == MI_OK){
  293.             Serial.println("You are B2CQSHOP VIP Member, The card has  $100 !");
  294.         }  
  295.     }
  296.     */
  297.  
  298.     // read and/or authenticate new password?
  299.     blockAddr = 11;     //11       
  300.     status = MFRC522_Auth(PICC_AUTHENT1A, blockAddr, sectorNewKeyA[blockAddr/4], serNum);   //??
  301.     if (status == MI_OK){
  302.         blockAddr = blockAddr - 3 ;
  303.         status = MFRC522_Read(blockAddr, str);
  304.         if (status == MI_OK){
  305.             Serial.println("Read from the card ,the data is : ");
  306.             for (i=0; i<16; i++){
  307.                 Serial.print(str[i],DEC);
  308.                 Serial.print(" , ");
  309.             }
  310.             Serial.println(" ");
  311.         }
  312.     }
  313.  
  314.  
  315.     blockAddr = 11;     //7    
  316.     status = MFRC522_Auth(PICC_AUTHENT1A, blockAddr, sectorNewKeyA[blockAddr/4], serNum);   //??
  317.     if (status == MI_OK){
  318.         blockAddr = blockAddr - 3 ;
  319.         status = MFRC522_Read(blockAddr, str);
  320.         if (status == MI_OK){
  321.             if(str[15] < moneyConsume){
  322.                 Serial.println(" The money is not enough !");
  323.             }else{
  324.                 str[15] = str[15] - moneyConsume;
  325.                 status = MFRC522_Write(blockAddr, str);
  326.                 if(status == MI_OK){
  327.                     Serial.print("You pay $18 for items in B2CQSHOP.COM . Now, Your money balance is :   $");
  328.                     Serial.print(str[15],DEC);
  329.                     Serial.println(" ");
  330.                 }
  331.             }
  332.         }
  333.     }
  334.  
  335.     blockAddr = 11;     //11       
  336.     status = MFRC522_Auth(PICC_AUTHENT1A, blockAddr, sectorNewKeyA[blockAddr/4], serNum);   //??
  337.     if (status == MI_OK){
  338.         blockAddr = blockAddr - 3 ;
  339.         status = MFRC522_Read(blockAddr, str);
  340.         if (status == MI_OK){
  341.             tmp = (int)(str[15] + moneyAdd) ;
  342.             //Serial.println(tmp,DEC);
  343.             if( tmp < (char)254){
  344.                 Serial.println(" The money of the card can not be more than 255 !");
  345.             }else{
  346.                 str[15] = str[15] + moneyAdd ;
  347.                 status = MFRC522_Write(blockAddr, str);
  348.                 if(status == MI_OK){
  349.                     Serial.print("You add $10 to your card in B2CQSHOP.COM , Your money balance is :  $");
  350.                     Serial.print(str[15],DEC);
  351.                     Serial.println(" ");
  352.                 }
  353.             }
  354.         }
  355.     }
  356.  
  357.     //Serial.println(" ");
  358.     MFRC522_Halt();
  359.     delay(200);
  360. }
  361. /////////////////EINDE LOOPGEDEELTE
  362.  
  363.  
  364. //--------------------RFID reader functions--------------------//
  365.  
  366.  
  367. //Write_MFRC5200
  368. //----------------------------------------------------------//
  369. /*
  370. * Function: Write_MFRC5200()
  371.  * Description: write a byte data into one register of MR RC522
  372.  * Input parameter: (addr--register, address val) --the value to be written
  373.  * Return: Null
  374.  */
  375. void Write_MFRC522(uchar addr, uchar val){
  376.   digitalWrite(chipSelectPin, LOW);
  377.   SPI.transfer((addr<<1)&0x7E);
  378.   SPI.transfer(val);
  379.   digitalWrite(chipSelectPin, HIGH);
  380. }
  381.  
  382.  
  383. //Read_MFRC522
  384. //----------------------------------------------------------//
  385. /*
  386. * Function: Read_MFRC522()
  387.  * Description: read a byte data in one register of MR RC522
  388.  * Input parameter: (addr--register address)
  389.  * Return: returns the read value
  390.  */
  391. uchar Read_MFRC522(uchar addr){
  392.   uchar val;
  393.   digitalWrite(chipSelectPin, LOW);
  394.   SPI.transfer(((addr<<1)&0x7E) | 0x80);   
  395.   val =SPI.transfer(0x00);
  396.   digitalWrite(chipSelectPin, HIGH);
  397.   return val;  
  398. }
  399.  
  400.  
  401. //SetBitMask
  402. //----------------------------------------------------------//
  403. /*
  404. * Function: SetBitMask()
  405.  * Description: set RC522 register bit
  406.  * Input parameter: (reg--register address, mask--value)
  407.  * Return: null
  408.  */
  409. void SetBitMask(uchar reg, uchar mask)  {
  410.   uchar tmp;
  411.   tmp = Read_MFRC522(reg);
  412.   Write_MFRC522(reg, tmp | mask);  // set bit mask
  413. }
  414.  
  415.  
  416. //ClearBitMask
  417. //----------------------------------------------------------//
  418. /*
  419. * Function: ClearBitMask()
  420.  * Description: clear RC522 register bit
  421.  * Input parameter: (reg--register address, mask--value)
  422.  * Return: null
  423.  */
  424. void ClearBitMask(uchar reg, uchar mask)  {
  425.   uchar tmp;
  426.   tmp = Read_MFRC522(reg);
  427.   Write_MFRC522(reg, tmp & (~mask));  // clear bit mask
  428. }
  429.  
  430.  
  431. //MFRC522_Reset
  432. //----------------------------------------------------------//
  433. /*
  434. * Function: RsetMFRC522()
  435.  * Description: reset RC522
  436.  * Input parameter: null
  437.  * Return: null
  438.  */
  439. void MFRC522_Reset(void){
  440.   Write_MFRC522(CommandReg, PCD_RESETPHASE);
  441. }
  442.  
  443.  
  444. //AntennaOn
  445. //----------------------------------------------------------//
  446. /*
  447. * Function: AntennaOn()
  448.  * Description: Turn on antenna, every time antenna is turned on/off you need at least 1ms delay
  449.  * Input parameter: null
  450.  * Return: null
  451.  */
  452. void AntennaOn(void){
  453.   uchar temp;
  454.   temp = Read_MFRC522(TxControlReg);
  455.   if (!(temp & 0x03)){
  456.     SetBitMask(TxControlReg, 0x03);
  457.   }
  458. }
  459.  
  460. //AntennaOff
  461. //----------------------------------------------------------//
  462. /*
  463. * Function: AntennaOff()
  464.  * Description: Turn on antenna, every time antenna is turned on/off you need at least 1ms delay
  465.  * Input parameter: null
  466.  * Return: null
  467.  */
  468. void AntennaOff(void){
  469.   ClearBitMask(TxControlReg, 0x03);
  470. }
  471.  
  472.  
  473.  
  474.  
  475. //MFRC522_Init
  476. //----------------------------------------------------------//
  477. /*
  478. * Function: InitMFRC522()
  479.  * Description: initilize RC522
  480.  * Input parameter: null
  481.  * Return: null
  482.  */
  483. void MFRC522_Init(void){
  484.   //bring RFID RESET pin HIGH
  485.   digitalWrite(NRSTPD,HIGH);
  486.   //call RFID reset() function
  487.   MFRC522_Reset();
  488.   //Timer: TPrescaler*TreloadVal/6.78MHz = 24ms
  489.   Write_MFRC522(TModeReg, 0x8D);    //Tauto=1; f(Timer) = 6.78MHz/TPreScaler
  490.   Write_MFRC522(TPrescalerReg, 0x3E);   //TModeReg[3..0] + TPrescalerReg
  491.   Write_MFRC522(TReloadRegL, 30);          
  492.   Write_MFRC522(TReloadRegH, 0);
  493.   Write_MFRC522(TxAutoReg, 0x40);   //100%ASK
  494.   Write_MFRC522(ModeReg, 0x3D);     //CRC???0x6363  ???
  495.   //ClearBitMask(Status2Reg, 0x08);     //MFCrypto1On=0
  496.   //Write_MFRC522(RxSelReg, 0x86);      //RxWait = RxSelReg[5..0]
  497.   //Write_MFRC522(RFCfgReg, 0x7F);          //RxGain = 48dB
  498.  
  499.   //turn ON RFID antenna to start waiting for card/badges to come into proximity
  500.   AntennaOn();      //????
  501. }
  502.  
  503.  
  504. //MFRC522_Request
  505. //----------------------------------------------------------//
  506. /*
  507. * Function: MFRC522_Request()
  508.  * Description: Searching card, read card type
  509.  * Input parameter: (reqMode--search methods, TagType--return card types)
  510.  
  511.  *     -RETURN CARD TYPE VALUES -
  512.  *     0x4400 = Mifare_UltraLight
  513.  *     0x0400 = Mifare_One(S50)
  514.  *     0x0200 = Mifare_One(S70)
  515.  *     0x0800 = Mifare_Pro(X)
  516.  *     0x4403 = Mifare_DESFire
  517.  
  518.  * return: return MI_OK (if success)
  519.  */
  520. uchar MFRC522_Request(uchar reqMode, uchar *TagType){
  521.   uchar status;  
  522.   uint backBits;      //the data bits that received
  523.   Write_MFRC522(BitFramingReg, 0x07);   //TxLastBists = BitFramingReg[2..0] ???
  524.  
  525.   TagType[0] = reqMode;
  526.   status = MFRC522_ToCard(PCD_TRANSCEIVE, TagType, 1, TagType, &backBits);
  527.  
  528.   if ((status != MI_OK) || (backBits != 0x10)){    
  529.     status = MI_ERR;
  530.   }
  531.   return status;
  532. }
  533.  
  534.  
  535.  
  536. //MFRC522_ToCard
  537. //----------------------------------------------------------//
  538. /*
  539. * Function: MFRC522_ToCard()
  540.  * Description: communicate between RC522 and ISO14443
  541.  * Input parameter: (command--MF522 command bits,
  542.  sendData--send data to card via rc522,
  543.  sendLen--send data length,
  544.  backData--the return data from card,
  545.  backLen--the length of return data)
  546.  
  547.  *return: return MI_OK (if success)
  548.  */
  549. uchar MFRC522_ToCard(uchar command, uchar *sendData, uchar sendLen, uchar *backData, uint *backLen){
  550.   uchar status = MI_ERR;
  551.   uchar irqEn = 0x00;
  552.   uchar waitIRq = 0x00;
  553.   uchar lastBits;
  554.   uchar n;
  555.   uint i;
  556.   switch (command){
  557.   case PCD_AUTHENT: // verify card password
  558.     {
  559.       irqEn = 0x12;
  560.       waitIRq = 0x10;
  561.       break;
  562.     }
  563.   case PCD_TRANSCEIVE: // send data in the FIFO
  564.     {
  565.       irqEn = 0x77;
  566.       waitIRq = 0x30;
  567.       break;
  568.     }
  569.   default:
  570.     break;
  571.   }
  572.  
  573.   Write_MFRC522(CommIEnReg, irqEn|0x80);    //Allow interruption
  574.   ClearBitMask(CommIrqReg, 0x80);       //Clear all the interrupt bits
  575.   SetBitMask(FIFOLevelReg, 0x80);       //FlushBuffer=1, FIFO initilizate
  576.  
  577.   Write_MFRC522(CommandReg, PCD_IDLE);  //NO action / cancel current command?
  578.  
  579.   for (i=0; i<sendLen; i++){  
  580.     Write_MFRC522(FIFODataReg, sendData[i]);    
  581.   }
  582.  
  583.   Write_MFRC522(CommandReg, command);
  584.   if (command == PCD_TRANSCEIVE){    
  585.     SetBitMask(BitFramingReg, 0x80);        //StartSend=1,transmission of data starts  
  586.   }
  587.  
  588.   //wait receive data is finished
  589.   i = 2000; //i should adjust according the clock, the maxium the waiting time should be 25 ms???
  590.   do{
  591.     //CommIrqReg[7..0]
  592.     //Set1 TxIRq RxIRq IdleIRq HiAlerIRq LoAlertIRq ErrIRq TimerIRq
  593.     n = Read_MFRC522(CommIrqReg);
  594.     i--;
  595.   }
  596.   while ((i!=0) && !(n&0x01) && !(n&waitIRq));
  597.  
  598.   ClearBitMask(BitFramingReg, 0x80);            //StartSend=0
  599.   if (i != 0){    
  600.     if(!(Read_MFRC522(ErrorReg) & 0x1B)){  // BufferOvfl Collerr CRCErr ProtecolErr
  601.       status = MI_OK;
  602.       if (n & irqEn & 0x01){  
  603.         status = MI_NOTAGERR;           //??  
  604.       }
  605.       if (command == PCD_TRANSCEIVE){
  606.         n = Read_MFRC522(FIFOLevelReg);
  607.         lastBits = Read_MFRC522(ControlReg) & 0x07;
  608.         if (lastBits){  
  609.           *backLen = (n-1)*8 + lastBits;  
  610.         }
  611.         else{  
  612.           *backLen = n*8;  
  613.         }
  614.         if (n == 0){  
  615.           n = 1;    
  616.         }
  617.         if (n > MAX_LEN){  
  618.           n = MAX_LEN;  
  619.         }
  620.  
  621.         //read the data from FIFO
  622.         for (i=0; i<n; i++){  
  623.           backData[i] = Read_MFRC522(FIFODataReg);    
  624.         }
  625.       }
  626.     }
  627.     else{  
  628.       status = MI_ERR;  
  629.     }
  630.   }
  631.   //SetBitMask(ControlReg,0x80);           //timer stops
  632.   //Write_MFRC522(CommandReg, PCD_IDLE);
  633.   return status;
  634. }
  635.  
  636.  
  637. //MFRC522_Anticoll
  638. //----------------------------------------------------------//
  639. /*
  640. * Function: MFRC522_Anticoll()
  641.  * Description: Prevent conflict, read the card serial number
  642.  * Input parameter: (serNum--return the 4 bytes card serial number, the 5th byte is recheck byte)
  643.  * return: returns MI_OK (if success)
  644.  */
  645. uchar MFRC522_Anticoll(uchar *serNum){
  646.   uchar status;
  647.   uchar i;
  648.   uchar serNumCheck=0;
  649.   uint unLen;
  650.   //ClearBitMask(Status2Reg, 0x08);     //TempSensclear
  651.   //ClearBitMask(CollReg,0x80);         //ValuesAfterColl
  652.   Write_MFRC522(BitFramingReg, 0x00);       //TxLastBists = BitFramingReg[2..0]
  653.  
  654.   serNum[0] = PICC_ANTICOLL;
  655.   serNum[1] = 0x20;
  656.   status = MFRC522_ToCard(PCD_TRANSCEIVE, serNum, 2, serNum, &unLen);
  657.  
  658.   if (status == MI_OK){
  659.  
  660.     //Verify card serial number
  661.     for (i=0; i<4; i++){  
  662.       serNumCheck ^= serNum[i];
  663.     }
  664.     if (serNumCheck != serNum[i]){  
  665.       status = MI_ERR;    
  666.     }
  667.   }
  668.   //SetBitMask(CollReg, 0x80);      //ValuesAfterColl=1
  669.   return status;
  670. }
  671.  
  672.  
  673.  
  674. //CalulateCRC
  675. //----------------------------------------------------------//
  676. /*
  677. * Function: CalulateCRC()
  678.  * Description: Use MF522 to caculate CRC
  679.  * Input parameter: (pIndata--the CRC data to be read, len--data length, pOutData--result of CRC)
  680.  * return: Null
  681.  */
  682. void CalulateCRC(uchar *pIndata, uchar len, uchar *pOutData){
  683.   uchar i, n;
  684.  
  685.   ClearBitMask(DivIrqReg, 0x04);            //CRCIrq = 0
  686.   SetBitMask(FIFOLevelReg, 0x80);           //Clear FIFO pointer
  687.   //Write_MFRC522(CommandReg, PCD_IDLE);
  688.  
  689.   for (i=0; i<len; i++){  
  690.     Write_MFRC522(FIFODataReg, *(pIndata+i));  
  691.   }
  692.   Write_MFRC522(CommandReg, PCD_CALCCRC);
  693.  
  694.   //wait CRC caculation to finish
  695.   i = 0xFF;
  696.   do {
  697.     n = Read_MFRC522(DivIrqReg);
  698.     i--;
  699.   }
  700.   while ((i!=0) && !(n&0x04));          //CRCIrq = 1
  701.  
  702.   pOutData[0] = Read_MFRC522(CRCResultRegL);
  703.   pOutData[1] = Read_MFRC522(CRCResultRegM);
  704. }
  705.  
  706.  
  707. //MFRC522_SelectTag
  708. //----------------------------------------------------------//
  709. /*
  710. * Function: MFRC522_SelectTag()
  711.  * Description: Select card, read card storage volume/value
  712.  * Input parameter: (serNum--Send card serial number)
  713.  * return: returns the card storage volume/value
  714.  */
  715. uchar MFRC522_SelectTag(uchar *serNum){
  716.   uchar i;
  717.   uchar status;
  718.   uchar size;
  719.   uint recvBits;
  720.   uchar buffer[9];
  721.  
  722.   //ClearBitMask(Status2Reg, 0x08);         //MFCrypto1On=0
  723.  
  724.   buffer[0] = PICC_SElECTTAG;
  725.   buffer[1] = 0x70;
  726.   for (i=0; i<5; i++){
  727.     buffer[i+2] = *(serNum+i);
  728.   }
  729.   CalulateCRC(buffer, 7, &buffer[7]);       //??
  730.   status = MFRC522_ToCard(PCD_TRANSCEIVE, buffer, 9, buffer, &recvBits);
  731.  
  732.   if ((status == MI_OK) && (recvBits == 0x18)) {  
  733.     size = buffer[0];
  734.   }
  735.   else{  
  736.     size = 0;    
  737.   }
  738.   return size;
  739. }
  740.  
  741.  
  742.  
  743. //MFRC522_Auth
  744. //----------------------------------------------------------//
  745. /*
  746. * Function: MFRC522_Auth()
  747.  * Description: verify card password
  748.  * Input parameters: (authMode--password verify mode, BlockAddr--Block address, Sectorkey--Block password, serNum--Card serial number (4 bytes))
  749.  
  750.  [-AUTH MODES TO USE-]
  751.  * 0x60 = verify A passowrd key
  752.  * 0x61 = verify B passowrd key],          
  753.  
  754.  * return: return MI_OK (if success)
  755.  */
  756. uchar MFRC522_Auth(uchar authMode, uchar BlockAddr, uchar *Sectorkey, uchar *serNum){
  757.   uchar status;
  758.   uint recvBits;
  759.   uchar i;
  760.   uchar buff[12];
  761.  
  762.   //Verify command + block address + buffer password + card SN
  763.   buff[0] = authMode;
  764.   buff[1] = BlockAddr;
  765.   for (i=0; i<6; i++){    
  766.     buff[i+2] = *(Sectorkey+i);  
  767.   }
  768.   for (i=0; i<4; i++) {    
  769.     buff[i+8] = *(serNum+i);  
  770.   }
  771.   status = MFRC522_ToCard(PCD_AUTHENT, buff, 12, buff, &recvBits);
  772.  
  773.   if ((status != MI_OK) || (!(Read_MFRC522(Status2Reg) & 0x08))){  
  774.     status = MI_ERR;  
  775.   }
  776.   return status;
  777. }
  778.  
  779.  
  780.  
  781. //MFRC522_Read
  782. //----------------------------------------------------------//
  783. /*
  784. * Function: MFRC522_Read()
  785.  * Description: Read data
  786.  * Input parameters: (blockAddr--block address, recvData--the block data which are read)
  787.  * return: returns MI_OK (if success)
  788.  */
  789. uchar MFRC522_Read(uchar blockAddr, uchar *recvData){
  790.   uchar status;
  791.   uint unLen;
  792.  
  793.   recvData[0] = PICC_READ;
  794.   recvData[1] = blockAddr;
  795.   CalulateCRC(recvData, 2, &recvData[2]);
  796.   status = MFRC522_ToCard(PCD_TRANSCEIVE, recvData, 4, recvData, &unLen);
  797.  
  798.   if ((status != MI_OK) || (unLen != 0x90)){
  799.     status = MI_ERR;
  800.   }
  801.   return status;
  802. }
  803.  
  804.  
  805.  
  806. //MFRC522_Write
  807. //----------------------------------------------------------//
  808. /*
  809. * Function: MFRC522_Write()
  810.  * Description: write block data
  811.  * Input parameters:  (blockAddr--block address, writeData--Write 16 bytes data into block)
  812.  * return: returns MI_OK (if success)
  813.  */
  814. uchar MFRC522_Write(uchar blockAddr, uchar *writeData){
  815.   uchar status;
  816.   uint recvBits;
  817.   uchar i;
  818.   uchar buff[18];
  819.  
  820.   buff[0] = PICC_WRITE;
  821.   buff[1] = blockAddr;
  822.   CalulateCRC(buff, 2, &buff[2]);
  823.   status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff, &recvBits);
  824.  
  825.   if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A)){  
  826.     status = MI_ERR;  
  827.   }
  828.  
  829.   if (status == MI_OK){
  830.  
  831.     for (i=0; i<16; i++){     //Write 16 bytes data into FIFO
  832.       buff[i] = *(writeData+i);  
  833.     }
  834.     CalulateCRC(buff, 16, &buff[16]);
  835.     status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 18, buff, &recvBits);
  836.  
  837.     if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A)){  
  838.       status = MI_ERR;  
  839.     }
  840.   }
  841.   return status;
  842. }
  843.  
  844.  
  845.  
  846. //MFRC522_Halt
  847. //----------------------------------------------------------//
  848. /*
  849.  * Function: MFRC522_Halt()
  850.  * Description: Command the cards into sleep mode
  851.  * Input parameters: null
  852.  * return: null
  853.  */
  854. void MFRC522_Halt(void){
  855.   uchar status;
  856.   uint unLen;
  857.   uchar buff[4];
  858.  
  859.   buff[0] = PICC_HALT;
  860.   buff[1] = 0;
  861.   CalulateCRC(buff, 2, &buff[2]);
  862.  
  863.   status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff,&unLen);
  864. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!