mfucfunc.c

此程序为13.56MHz的RFID底层读写卡程序

      ResetInfo(MInfo);
      MRcvBuffer[0] = req_code;
      MInfo.nBytesToSend   = 1;
      status = PcdSingleResponseCmd(PCD_TRANSCEIVE,
                         MRcvBuffer,
                         MRcvBuffer,
                         &MInfo);

      if (status)      // error occured
      {
                //nByte=ReadRC(RegFIFOLength);
                //Temp=ReadRC(RegFIFOData);
         *atq = 0;

      }
      else
      {
         if (MInfo.nBitsReceived != 16) // 2 bytes expected
         {
            *atq = 0;

            //nByte=ReadRC(RegFIFOLength);
            //Temp=ReadRC(RegFIFOData);
            //Temp1=ReadRC(RegFIFOData);
            status = MI_BITCOUNTERR;
         }
         else
         {
            status = MI_OK;
            memcpy(atq,MRcvBuffer,2);
         }
      }
   }
   return status;
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E    A N T I C O L L I S I O N
// for standard select
///////////////////////////////////////////////////////////////////////
char Mf500PiccAnticoll (unsigned char   bcnt,
                     unsigned char   *snr)
{
   return Mf500PiccCascAnticoll(0x93,bcnt,snr); // first cascade level
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E    A N T I C O L L I S I O N
// for extended serial numbers
///////////////////////////////////////////////////////////////////////
char Mf500PiccCascAnticoll (unsigned char   select_code,
                         unsigned char   bcnt,
                         unsigned char    *snr)
{
   char    status = MI_OK;
   char    snr_in[4];         // copy of the input parameter snr
   char    nbytes = 0;        // how many bytes received
   char    nbits = 0;         // how many bits received
   char    complete = 0;      // complete snr recived
   char    i        = 0;
   char    byteOffset = 0;
   unsigned char   snr_crc;   // check byte calculation
   unsigned char   snr_check;
   unsigned char   dummyShift1;       // dummy byte for snr shift
   unsigned char   dummyShift2;       // dummy byte for snr shift

   //************* Initialisierung ******************************
   if ((status = Mf500PcdSetDefaultAttrib()) == MI_OK)
   {
      PcdSetTmo(106);

      memcpy(snr_in,snr,4);

      WriteRC(RegDecoderControl,0x28); // ZeroAfterColl aktivieren
      ClearBitMask(RegControl,0x08);    // disable crypto 1 unit

      //************** Anticollision Loop ***************************
      complete=0;
      while (!complete && (status == MI_OK) )
      {
         ResetInfo(MInfo);
         WriteRC(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
         nbits = bcnt % 8;   // remaining number of bits
         if (nbits)
         {
                //Temp=nbits<<4|nbits;
                //WriteRC(RegBitFraming,Temp);
            WriteRC(RegBitFraming,nbits << 4 | nbits); // TxLastBits/RxAlign auf nb_bi
            nbytes = bcnt / 8 + 1;
            // number of bytes known

            // in order to solve an inconsistancy in the anticollision sequence
            // (will be solved soon), the case of 7 bits has to be treated in a
            // separate way
            if (nbits == 7 )
            {
               MInfo.cmd = PICC_ANTICOLL1;   // pass command flag to ISR
               WriteRC(RegBitFraming,nbits); // reset RxAlign to zero
            }
         }
         else
         {
            nbytes = bcnt / 8;
         }

         MRcvBuffer[0] = select_code;
         MRcvBuffer[1] = 0x20 + ((bcnt/8) << 4) + nbits; //number of bytes send

         for (i = 0; i < nbytes; i++)  // Sende Buffer beschreiben
         {
            MRcvBuffer[i + 2] = snr_in[i];
         }
         MInfo.nBytesToSend   = 2 + nbytes;

         status = PcdSingleResponseCmd(PCD_TRANSCEIVE,
                            MRcvBuffer,
                            MRcvBuffer,
                            &MInfo);

          // in order to solve an inconsistancy in the anticollision sequence
          // (will be solved soon), the case of 7 bits has to be treated in a
          // separate way
         if (nbits == 7)
         {
            // reorder received bits
            dummyShift1 = 0x00;
            for (i = 0; i < MInfo.nBytesReceived; i++)
            {
                dummyShift2 = MRcvBuffer[i];
                MRcvBuffer[i] = (dummyShift1 >> (i+1)) | (MRcvBuffer[i] << (7-i));
                dummyShift1 = dummyShift2;
            }
            MInfo.nBitsReceived -= MInfo.nBytesReceived; // subtract received parity bits
            // recalculation of collision position
            if ( MInfo.collPos ) MInfo.collPos += 7 - (MInfo.collPos + 6) / 9;
         }

         if ( status == MI_OK || status == MI_COLLERR)    // no other occured
         {
            // R e s p o n s e   P r o c e s s i n g
            if ( MInfo.nBitsReceived != (40 - bcnt) ) // not 5 bytes answered
            {
               status = MI_BITCOUNTERR;
            }
            else
            {
               byteOffset = 0;
               if ( nbits != 0 )           // last byte was not complete
               {
                  snr_in[nbytes - 1] = snr_in[nbytes - 1] | MRcvBuffer[0];
                  byteOffset = 1;
               }
               for ( i =0; i < (4 - nbytes); i++)
               {
                  snr_in[nbytes + i] = MRcvBuffer[i + byteOffset];
               }

               if (status != MI_COLLERR ) // no error and no collision
               {
                  // SerCh check
                  snr_crc = snr_in[0] ^ snr_in[1] ^ snr_in[2] ^ snr_in[3];
                  snr_check = MRcvBuffer[MInfo.nBytesReceived - 1];
                  if (snr_crc != snr_check)
                  {
                     status = MI_SERNRERR;
                  }
                  else
                  {
                     complete = 1;
                  }
               }
               else                   // collision occured
               {
                  bcnt = bcnt + MInfo.collPos - nbits;
                  status = MI_OK;
               }
            }
        }
      }
   }
   if (status == MI_OK)
   {
      // transfer snr_in to snr
      memcpy(snr,snr_in,4);
   }
   else
   {
      memcpy(snr,"0000",4);
   }

   //----------------------Einstellungen aus Initialisierung ruecksetzen
   ClearBitMask(RegDecoderControl,0x20); // ZeroAfterColl disable

   return status;
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E    S E L E C T
// for std. select
///////////////////////////////////////////////////////////////////////
char Mf500PiccSelect(unsigned char   *snr,
                  unsigned char   *sak)
{
   return Mf500PiccCascSelect(0x93,snr,sak); // first cascade level
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E    C A S C A D E D   S E L E C T
//  for extended serial number
///////////////////////////////////////////////////////////////////////
char Mf500PiccCascSelect(unsigned char   select_code,
                        unsigned char   *snr,
                        unsigned char   *sak)
{
   char   status = MI_OK;

   if ((status = Mf500PcdSetDefaultAttrib()) == MI_OK)
   {
      PcdSetTmo(106);

      WriteRC(RegChannelRedundancy,0x0f); // RxCRC,TxCRC, Parity enable
      ClearBitMask(RegControl,0x08);    // disable crypto 1 unit

      //************* Cmd Sequence **********************************
      ResetInfo(MInfo);
      MRcvBuffer[0] = select_code;
      MRcvBuffer[1] = 0x70;         // number of bytes send

      memcpy(MRcvBuffer + 2,snr,4);
      MRcvBuffer[6] = MRcvBuffer[2]
                      ^ MRcvBuffer[3]
                      ^ MRcvBuffer[4]
                      ^ MRcvBuffer[5];
      MInfo.nBytesToSend   = 7;
      status = PcdSingleResponseCmd(PCD_TRANSCEIVE,
                          MRcvBuffer,
                          MRcvBuffer,
                          &MInfo);

      *sak = 0;
      if (status == MI_OK)    // no timeout occured
      {
         if (MInfo.nBitsReceived != 8)    // last byte is not complete
         {
            status = MI_BITCOUNTERR;
         }
         else
         {
            *sak = MRcvBuffer[0];
            memcpy(MLastSelectedSnr,snr,4);
         }
      }
   }
   return status;
}

///////////////////////////////////////////////////////////////////////
//       M I F A R E   P I C C   A C T I V A T I O N    S E Q E N C E
///////////////////////////////////////////////////////////////////////
/*char Mf500PiccActivateIdle(unsigned char   br,
                           unsigned char    *atq,
                           unsigned char   *sak,
                           unsigned char   *uid,
                           unsigned char   *uid_len)
{
  unsigned char   cascade_level;
  unsigned char   sel_code;
  unsigned char   uid_index;
  signed char   status;
  unsigned char   cmdASEL;

  *uid_len      = 0;

  //call activation with def. divs
  status = Mf500PcdSetDefaultAttrib();
  if (status == MI_OK)
  {
     status = Mf500PiccCommonRequest(PICC_REQIDL,atq);
  }
  if (status == MI_OK)
  {
     if((atq[0] & 0x1F) == 0x00) // check lower 5 bits, for tag-type
                                 // all tags within this 5 bits have to
                                 // provide a bitwise anticollision
     {
        status = MI_NOBITWISEANTICOLL;
     }
  }
  if (status == MI_OK)
  {
      //Get UID in 1 - 3 levels (standard, [double], [triple] )
      //-------
      switch(br)
      {
         case 0: cmdASEL = PICC_ANTICOLL1; break;
         default:
              status = MI_BAUDRATE_NOT_SUPPORTED; break;
      }
  }
  if (status == MI_OK)
  {
      cascade_level = 0;
      uid_index     = 0;
      do
      {
        //Select code depends on cascade level
        sel_code   = cmdASEL + (2 * cascade_level);
        cmdASEL = PICC_ANTICOLL1; // reset anticollistion level for calculation
        //ANTICOLLISION
        status = Mf500PiccCascAnticoll(sel_code, 0, &uid[uid_index]);