m500auc.c

学校水ＰＯＳ读卡程序

     Temp = ReadIO(RegClockQControl);

     WriteIO(RegClockQControl,0x40);

     Temp = ReadIO(RegClockQControl);

     delay_50us(2);  // wait approximately 100 us - calibration in progress
     ClearBitMask(RegClockQControl,0x40); // clear bit ClkQCalib for
                                          // further calibration

     // The following values for RegBitPhase and
     // RegRxThreshold represents an optimal
     // value for our demo package. For user
     // implementation some changes could be
     // necessary
     // initialize bit phase


     WriteIO(RegBitPhase,0xAD);//page3调整发射器河接收器的相位差，该值影响数据接受质量
                               //该寄存器复位值为0xAD;

     Temp = ReadIO(RegBitPhase);

     // initialize minlevel
     WriteIO(RegRxThreshold,0xFF);//选择bit解码的阀值
                                  //(7654bit)Minnlevel定义解码起能够接受的最小信号
                                  //若信号的强度低于该值，则不被处理
                                  //(3210bit)定义Manchester编码的信号里弱半bit相对
                                  //强半bit产生冲突必须达到的最小值
                                  //该寄存器复位值为oxFF. 

     Temp = ReadIO(RegRxThreshold);

     // disable auto power down
     WriteIO(RegRxControl2,0x01);//解码控制及选择接收源
                                 //赋值0x01 ：选择Q时钟作为接收器时钟
                                 //接收器始终打开
                                 //选择内部解调器
     Temp = ReadIO(RegRxControl2);
     // Depending on the processing speed of the
     // operation environment, the waterlevel
     // can be adapted. (not very critical for
     // mifare applications)
     // initialize waterlevel to value 4
     WriteIO(RegFIFOLevel,0x04);//定义FIFO向上或向下的溢出级别
                                //若FIFO里剩下的空间(64-FIFOLength)小于等于Waterlevel则HiAlert=1.
                                //若FIFO里已有的数据FIFOLength)小于等于WaterLever则LoAlert=1;

     Temp = ReadIO(RegFIFOLevel);
     //Timer configuration
     WriteIO(RegTimerControl,0x02);  //选择Timer时钟的启动和停止条件
                                     //数据发送结束后Timer自动启动
									 // TStopRxEnd=0,TStopRxBeg=0,
                                     // TStartTxEnd=1,TStartTxBeg=0
                                     // timer must be stopped manually

     Temp = ReadIO(RegTimerControl);
     M500PcdSetTmo(1);               // short timeout

     WriteIO(RegIRqPinConfig,0x03); // interrupt active low enable

     Temp = ReadIO(RegIRqPinConfig);//定义管脚输出电平
                                    //IRQ管脚为Irq bit 的反相输出
                                    //IRQ管脚为标准的CMOS输出

     M500PcdRfReset(1);            // Rf - reset and enable output driver

     Pt = &MKeys[0][0];
     // initialize internal key memory
     for (i = 0; i < 16; i++)
     {
        for (j = 0; j < 12; j++)
           {
             MKeys[i][j] = 0x00;
             Pt++;
           }
     }

     memcpy(MKeys,AledKey,192);

   }

   return status;
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E   R E M O T E   A N T E N N A
//  Configuration of slave module
///////////////////////////////////////////////////////////////////////
char M500PcdMfInOutSlaveConfig(void)
{
   char data status = MI_OK;

   FlushFIFO();    // empty FIFO
   ResetInfo(MInfo);
   MSndBuffer[0] = 0x10; // addr low byte
   MSndBuffer[1] = 0x00; // addr high byte

   MSndBuffer[2] = 0x00; // Page
   MSndBuffer[3] = 0x7B; // RegTxControl modsource 11,InvTx2,Tx2RFEn,TX1RFEn
   MSndBuffer[4] = 0x3F; // RegCwConductance
   MSndBuffer[5] = 0x3F; // RFU13
   MSndBuffer[6] = 0x19; // RFU14
   MSndBuffer[7] = 0x13; // RegModWidth
   MSndBuffer[8] = 0x00; // RFU16
   MSndBuffer[9] = 0x00; // RFU17

   MSndBuffer[10] = 0x00; // Page
   MSndBuffer[11] = 0x73; // RegRxControl1
   MSndBuffer[12] = 0x08; // RegDecoderControl
   MSndBuffer[13] = 0x6c; // RegBitPhase
   MSndBuffer[14] = 0xFF; // RegRxThreshold
   MSndBuffer[15] = 0x00; // RFU1D
   MSndBuffer[16] = 0x00; // RegRxControl2
   MSndBuffer[17] = 0x00; // RegClockQControl

   MSndBuffer[18] = 0x00; // Page
   MSndBuffer[19] = 0x06; // RegRxWait
   MSndBuffer[20] = 0x03; // RegChannelRedundancy
   MSndBuffer[21] = 0x63; // RegCRCPresetLSB
   MSndBuffer[22] = 0x63; // RegCRCPresetMSB
   MSndBuffer[23] = 0x0;  // RFU25
   MSndBuffer[24] = 0x04; // RegMfOutSelect enable mfout = manchester HT
   MSndBuffer[25] = 0x00; // RFU27

   // PAGE 5      FIFO, Timer and IRQ-Pin Configuration
   MSndBuffer[26] = 0x00; // Page
   MSndBuffer[27] = 0x08; // RegFIFOLevel
   MSndBuffer[28] = 0x07; // RegTimerClock
   MSndBuffer[29] = 0x06; // RegTimerControl
   MSndBuffer[30] = 0x0A; // RegTimerReload
   MSndBuffer[31] = 0x02; // RegIRqPinConfig
   MSndBuffer[32] = 0x00; // RFU
   MSndBuffer[33] = 0x00; // RFU
   MInfo.nBytesToSend   = 34;

   status = M500PcdCmd(PCD_WRITEE2,
                       MSndBuffer,
                       MRcvBuffer,
                       &MInfo); // write e2
   return status;
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E   R E M O T E   A N T E N N A
//  Configuration of master module
///////////////////////////////////////////////////////////////////////
char M500PcdMfInOutMasterConfig(void)
{
   WriteIO(RegRxControl2,0x42);
   WriteIO(RegTxControl,0x10);
   WriteIO(RegBitPhase,0x11);

   return MI_OK;
}

///////////////////////////////////////////////////////////////////////
//          M A S T E R   K E Y   L O A D
///////////////////////////////////////////////////////////////////////
char M500PcdLoadMk(unsigned char  auth_mode,  // KEYA or KEYB
                   unsigned char  key_addr,   // 0 <= key_addr <= 15
                   unsigned char  *mk)        // 6 bytes uncoded master key
{
   unsigned char data offset = (auth_mode == PICC_AUTHENT1A) ? 0 : 6;

   memcpy(MKeys[key_addr] + offset,mk,6);
   return MI_OK;
}

///////////////////////////////////////////////////////////////////////
//          E E P R O M   M A S T E R   K E Y   L O A D
///////////////////////////////////////////////////////////////////////
char M500PcdLoadKeyE2(unsigned char key_type,
                          unsigned char sector,
                          unsigned char *uncoded_keys)
{
   char data status = MI_OK;
   // eeprom address calculation
   // 0x80 ... offset
   // key_sector ... sector
   // 0x18 ... 2 * 12 = 24 = 0x18
   unsigned short data e2addr = 0x80 + sector * 0x18;
   unsigned char data *e2addrbuf = (unsigned char*)&e2addr;
   unsigned char data keycoded[12];

   if (key_type == PICC_AUTHENT1B)
      e2addr += 12; // key B offset

   FlushFIFO();    // empty FIFO
   ResetInfo(MInfo);

   M500HostCodeKey(uncoded_keys,keycoded);
   memcpy(MSndBuffer,e2addrbuf,2); // write low and high byte of address
   MSndBuffer[2] = MSndBuffer[0];    // Move the LSB of the 2-bytes
   MSndBuffer[0] = MSndBuffer[1];    // address to the first byte
   MSndBuffer[1] = MSndBuffer[2];
   memcpy(&MSndBuffer[2],keycoded,12); // write 12 bytes of coded keys
   MInfo.nBytesToSend   = 14;

   // write load command
   status = M500PcdCmd(PCD_WRITEE2,
			MSndBuffer,
			MRcvBuffer,
			&MInfo);

   return status;
}

///////////////////////////////////////////////////////////////////////
//          E E P R O M   R E A D(读取EEPROM中的值)                   //
//          形参：起始地址
//                读取字节数
//                保存地址
///////////////////////////////////////////////////////////////////////
char PcdReadE2(unsigned short startaddr,
               unsigned char length,
               unsigned char * _data)
{
   char status = MI_OK;
     Pt = &MSndBuffer;
     // ************* Cmd Sequence **********************************
     ResetInfo(MInfo);
                         //宏定义的部分
                         // #define ResetInfo(info)    \
                         //       info.cmd            = 0; \
                         //       info.status         = MI_OK;\
                         //       info.irqSource      = 0;   \
                         //       info.nBytesSent     = 0;   \
                         //       info.nBytesToSend   = 0;  \
                         //       info.nBytesReceived = 0;  \
                         //       info.nBitsReceived  = 0;   \
                         //       info.collPos        = 0;             



     MSndBuffer[0] = startaddr & 0xFF;        //低字节
     MSndBuffer[1] = (startaddr >> 8) & 0xFF; //高字节
     MSndBuffer[2] = length;                  //数据长度
     MInfo.nBytesToSend   = 3;

     status = M500PcdCmd(PCD_READE2,
                         MSndBuffer,
                         MRcvBuffer,
                         &MInfo);
    if (status == MI_OK)
    {
      
       memcpy(_data,MRcvBuffer,length);
       
    }
    else                                     // Response Processing
    {
       _data[0] = 0;
    }
    return status ;
}

///////////////////////////////////////////////////////////////////////
//          E E P R O M   W R I T E
///////////////////////////////////////////////////////////////////////
char PcdWriteE2(unsigned short startaddr,
                unsigned char length,
                unsigned char* _data)
{
   char status = MI_OK;

     // ************* Cmd Sequence **********************************
   ResetInfo(MInfo);
   MSndBuffer[0] = startaddr & 0xFF;
   MSndBuffer[1] = (startaddr >> 8) & 0xFF;
   memcpy(MSndBuffer + 2,_data,length);

   MInfo.nBytesToSend   = length + 2;

   status = M500PcdCmd(PCD_WRITEE2,
                       MSndBuffer,
                       MRcvBuffer,
                       &MInfo); // write e2
   return status;
}

///////////////////////////////////////////////////////////////////////
//          C O N F I G   M F O U T   S E L E C T
///////////////////////////////////////////////////////////////////////
char M500PcdMfOutSelect(unsigned char type)
{
   WriteIO(RegMfOutSelect,type&0x7);
   return MI_OK;
}

///////////////////////////////////////////////////////////////////////
//          W R I T E   R E G I S T E R
///////////////////////////////////////////////////////////////////////
char M500PcdWriteRegister(unsigned char Reg, unsigned char value)
{
   WriteIO(Reg,value);
   return MI_OK;
}

///////////////////////////////////////////////////////////////////////
//          R E A D   R E G I S T E R
///////////////////////////////////////////////////////////////////////
char M500PcdReadRegister(unsigned char Reg)
{
   char value;

   value = ReadIO(Reg);
   return (value);
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E    R E Q U E S T
///////////////////////////////////////////////////////////////////////
char M500PiccRequest(unsigned char req_code, // request code ALL = 0x52
                                             // or IDLE = 0x26
                   unsigned char *atq)     // answer to request
{
   return M500PiccCommonRequest(req_code,atq);
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E   C O M M O N   R E Q U E S T
///////////////////////////////////////////////////////////////////////
char M500PiccCommonRequest(unsigned char req_code,
                         unsigned char *atq)
{
   char data status = MI_OK;

    //************* initialize ******************************
   WriteIO(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
   Temp = ReadIO(RegChannelRedundancy);

   ClearBitMask(RegControl,0x08);    // disable crypto 1 unit
   WriteIO(RegBitFraming,0x07);        // set TxLastBits to 7
   SetBitMask(RegTxControl,0x03);    // Tx2RF-En, Tx1RF-En enable

   ResetInfo(MInfo);
   MSndBuffer[0] = req_code;
   MInfo.nBytesToSend   = 1;
   status = M500PcdCmd(PCD_TRANSCEIVE,   //PCD_TRANSCEIVE:收发数据命令 
                      MSndBuffer,
                      MRcvBuffer,
                      &MInfo);

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