STM32与MFC522通信，IC卡读写

ID:472833 · 发表于 2019-1-25 14:41

#include "mfrc522.h"
#include "stm32f0xx.h"
#include <delay.h>
//#include <string.h>

#define MAXRLEN 18
/////////////////////////////////////////////////////////////////////
//功能：寻卡
//参数说明: req_code[IN]:寻卡方式
//             0x52 = 寻感应区内所有符合14443A标准的卡
//             0x26 = 寻未进入休眠状态的卡
//          pTagType[OUT]：卡片类型代码
//             0x4400 = Mifare_UltraLight
//             0x0400 = Mifare_One(S50)
//             0x0200 = Mifare_One(S70)
//             0x0800 = Mifare_Pro(X)
//             0x4403 = Mifare_DESFire
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdRequest(unsigned char req_code,unsigned char *pTagType)
{
char status;
unsigned int  unLen;
unsigned char ucComMF522Buf[MAXRLEN];
//  unsigned char xTest ;
ClearBitMask(Status2Reg,0x08);
WriteRawRC(BitFramingReg,0x07);

//  xTest = ReadRawRC(BitFramingReg);
//  if(xTest == 0x07 )
// { LED_GREEN  =0 ;}
// else {LED_GREEN =1 ;while(1){}}
SetBitMask(TxControlReg,0x03);

ucComMF522Buf[0] = req_code;

status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);//功能：通过RC522和ISO14443卡通讯
//    if(status  == MI_OK )
// { LED_GREEN  =0 ;}
// else {LED_GREEN =1 ;}
if ((status == MI_OK) && (unLen == 0x10))
{
   *pTagType    = ucComMF522Buf[0];
   *(pTagType+1) = ucComMF522Buf[1];
}
else
{ status = MI_ERR; }

return status;
}

/////////////////////////////////////////////////////////////////////
//功能：防冲撞
//参数说明: pSnr[OUT]:卡片序列号，4字节
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdAnticoll(unsigned char *pSnr)
{
char status;
unsigned char i,snr_check=0;
unsigned int  unLen;
unsigned char ucComMF522Buf[MAXRLEN];

ClearBitMask(Status2Reg,0x08);
WriteRawRC(BitFramingReg,0x00);
ClearBitMask(CollReg,0x80);

ucComMF522Buf[0] = PICC_ANTICOLL1;
ucComMF522Buf[1] = 0x20;

status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);

if (status == MI_OK)
{
   for (i=0; i<4; i++)
      {
         *(pSnr+i)  = ucComMF522Buf[i];
         snr_check ^= ucComMF522Buf[i];
      }
      if (snr_check != ucComMF522Buf[i])
      { status = MI_ERR; }
}

SetBitMask(CollReg,0x80);
return status;
}

/////////////////////////////////////////////////////////////////////
//功能：选定卡片
//参数说明: pSnr[IN]:卡片序列号，4字节
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdSelect(unsigned char *pSnr)
{
char status;
unsigned char i;
unsigned int  unLen;
unsigned char ucComMF522Buf[MAXRLEN];

ucComMF522Buf[0] = PICC_ANTICOLL1;
ucComMF522Buf[1] = 0x70;
ucComMF522Buf[6] = 0;
for (i=0; i<4; i++)
{
ucComMF522Buf[i+2] = *(pSnr+i);
ucComMF522Buf[6]  ^= *(pSnr+i);
}
CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);

ClearBitMask(Status2Reg,0x08);

status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);

if ((status == MI_OK) && (unLen == 0x18))
{ status = MI_OK;  }
else
{ status = MI_ERR; }

return status;
}

/////////////////////////////////////////////////////////////////////
//功能：验证卡片密码
//参数说明: auth_mode[IN]: 密码验证模式
//                0x60 = 验证A密钥
//                0x61 = 验证B密钥
//       addr[IN]：块地址
//       pKey[IN]：密码
//       pSnr[IN]：卡片序列号，4字节
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
{
char status;
unsigned int  unLen;
unsigned char i,ucComMF522Buf[MAXRLEN];

ucComMF522Buf[0] = auth_mode;
ucComMF522Buf[1] = addr;
for (i=0; i<6; i++)
{ ucComMF522Buf[i+2] = *(pKey+i); }
for (i=0; i<6; i++)
{ ucComMF522Buf[i+8] = *(pSnr+i); }
// memcpy(&ucComMF522Buf[2], pKey, 6);
// memcpy(&ucComMF522Buf[8], pSnr, 4);

status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
{ status = MI_ERR; }

return status;
}

/////////////////////////////////////////////////////////////////////
//功能：读取M1卡一块数据
//参数说明: addr[IN]：块地址
//       pData[OUT]：读出的数据，16字节
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdRead(unsigned char addr,unsigned char *pData)
{
char status;
unsigned int  unLen;
unsigned char i,ucComMF522Buf[MAXRLEN];

ucComMF522Buf[0] = PICC_READ;
ucComMF522Buf[1] = addr;
CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
if ((status == MI_OK) && (unLen == 0x90))
// { memcpy(pData, ucComMF522Buf, 16); }
{
      for (i=0; i<16; i++)
      { *(pData+i) = ucComMF522Buf[i]; }
}
else
{ status = MI_ERR; }

return status;
}

/////////////////////////////////////////////////////////////////////
//功能：写数据到M1卡一块
//参数说明: addr[IN]：块地址
//       pData[IN]：写入的数据，16字节
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdWrite(unsigned char addr,unsigned char *pData)
{
char status;
unsigned int  unLen;
unsigned char i,ucComMF522Buf[MAXRLEN];

ucComMF522Buf[0] = PICC_WRITE;
ucComMF522Buf[1] = addr;
CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

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

if (status == MI_OK)
{
      //memcpy(ucComMF522Buf, pData, 16);

      for (i=0; i<16; i++)
      { ucComMF522Buf[i] = *(pData+i); }
      CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);

      status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
      if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
      { status = MI_ERR; }
}

return status;
}

/////////////////////////////////////////////////////////////////////
//功能：命令卡片进入休眠状态
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdHalt(void)
{
unsigned int  unLen;
unsigned char ucComMF522Buf[MAXRLEN];

ucComMF522Buf[0] = PICC_HALT;
ucComMF522Buf[1] = 0;
CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

return MI_OK;
}

/////////////////////////////////////////////////////////////////////
//用MF522计算CRC16函数
/////////////////////////////////////////////////////////////////////
void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
{
unsigned char i,n;
ClearBitMask(DivIrqReg,0x04);
WriteRawRC(CommandReg,PCD_IDLE);
SetBitMask(FIFOLevelReg,0x80);
for (i=0; i<len; i++)
{ WriteRawRC(FIFODataReg, *(pIndata+i)); }
WriteRawRC(CommandReg, PCD_CALCCRC);
i = 0xFF;
do
{
      n = ReadRawRC(DivIrqReg);
      i--;
}
while ((i!=0) && !(n&0x04));
pOutData[0] = ReadRawRC(CRCResultRegL);
pOutData[1] = ReadRawRC(CRCResultRegM);
}

/////////////////////////////////////////////////////////////////////
//功能：复位RC522
//返回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdReset(void)
{
RST_H;
delay_10ms(1);
RST_L;
delay_10ms(1);
RST_H;
   delay_10ms(10);

if(ReadRawRC(0x02) == 0x80)
{
//LED_ON;
delay_10ms(10);
//LED_OFF;
delay_10ms(10);
//LED_ON;
delay_10ms(10);
//LED_OFF;
delay_10ms(10);
}

WriteRawRC(CommandReg,PCD_RESETPHASE);

WriteRawRC(ModeReg,0x3D);          //和Mifare卡通讯，CRC初始值0x6363
WriteRawRC(TReloadRegL,30);
WriteRawRC(TReloadRegH,0);
WriteRawRC(TModeReg,0x8D);
WriteRawRC(TPrescalerReg,0x3E);
WriteRawRC(TxAutoReg,0x40);
return MI_OK;
}
//////////////////////////////////////////////////////////////////////
//设置RC632的工作方式
//////////////////////////////////////////////////////////////////////
char M500PcdConfigISOType(unsigned char type)
{
if (type == 'A')                   //ISO14443_A
{
   ClearBitMask(Status2Reg,0x08);

/*    WriteRawRC(CommandReg,0x20); //as default
   WriteRawRC(ComIEnReg,0x80);    //as default
   WriteRawRC(DivlEnReg,0x0);    //as default
   WriteRawRC(ComIrqReg,0x04);    //as default
   WriteRawRC(DivIrqReg,0x0);    //as default
   WriteRawRC(Status2Reg,0x0);//80 //trun off temperature sensor
   WriteRawRC(WaterLevelReg,0x08); //as default
   WriteRawRC(ControlReg,0x20); //as default
   WriteRawRC(CollReg,0x80); //as default
*/
   WriteRawRC(ModeReg,0x3D);//3F
/*    WriteRawRC(TxModeReg,0x0);    //as default???
   WriteRawRC(RxModeReg,0x0);    //as default???
   WriteRawRC(TxControlReg,0x80);  //as default???

   WriteRawRC(TxSelReg,0x10);    //as default???
*/
   WriteRawRC(RxSelReg,0x86);//84
//    WriteRawRC(RxThresholdReg,0x84);//as default
//    WriteRawRC(DemodReg,0x4D);    //as default

//    WriteRawRC(ModWidthReg,0x13);//26
   WriteRawRC(RFCfgReg,0x7F); //4F
/* WriteRawRC(GsNReg,0x88);       //as default???
   WriteRawRC(CWGsCfgReg,0x20); //as default???
   WriteRawRC(ModGsCfgReg,0x20); //as default???
*/
      WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
   WriteRawRC(TReloadRegH,0);
   WriteRawRC(TModeReg,0x8D);
   WriteRawRC(TPrescalerReg,0x3E);


  //    PcdSetTmo(106);
   delay_10ms(1);
   PcdAntennaOn();
}
else{ return (char)-1; }

return MI_OK;
}
/////////////////////////////////////////////////////////////////////
//功能：读RC632寄存器
//参数说明：Address[IN]:寄存器地址
//返回：读出的值
/////////////////////////////////////////////////////////////////////
unsigned char ReadRawRC(unsigned char Address)
{
   unsigned char i, ucAddr;
   unsigned char ucResult=0;

   NSS_L;
   ucAddr = ((Address<<1)&0x7E)|0x80;

   for(i=8;i>0;i--)
   {
      SCK_L;
        if(ucAddr&0x80)
         MOSI_H;
   else
   MOSI_L;
      SCK_H;
      ucAddr <<= 1;
   }

   for(i=8;i>0;i--)
   {
      SCK_L;
      ucResult <<= 1;
      SCK_H;
   if(READ_MISO == 1)
         ucResult |= 1;
   }

   NSS_H;
   SCK_H;
   return ucResult;
}

/////////////////////////////////////////////////////////////////////
//功能：写RC632寄存器
//参数说明：Address[IN]:寄存器地址
//       value[IN]:写入的值
/////////////////////////////////////////////////////////////////////
void WriteRawRC(unsigned char Address, unsigned char value)
{
unsigned char i, ucAddr;

SCK_L;
NSS_L;
ucAddr = ((Address<<1)&0x7E);

for(i=8;i>0;i--)
{
if(ucAddr&0x80)
        MOSI_H;
else
MOSI_L;
      SCK_H;
      ucAddr <<= 1;
      SCK_L;
}

for(i=8;i>0;i--)
{
if(value&0x80)
        MOSI_H;
else
MOSI_L;
      SCK_H;
      value <<= 1;
      SCK_L;
}
NSS_H;
SCK_H;
}

/////////////////////////////////////////////////////////////////////
//功能：置RC522寄存器位
//参数说明：reg[IN]:寄存器地址
//       mask[IN]:置位值
/////////////////////////////////////////////////////////////////////
void SetBitMask(unsigned char reg,unsigned char mask)
{
char tmp = 0x0;
tmp = ReadRawRC(reg);
WriteRawRC(reg,tmp | mask);  // set bit mask
}

/////////////////////////////////////////////////////////////////////
//功能：清RC522寄存器位
//参数说明：reg[IN]:寄存器地址
//       mask[IN]:清位值
/////////////////////////////////////////////////////////////////////
void ClearBitMask(unsigned char reg,unsigned char mask)
{
char tmp = 0x0;
tmp = ReadRawRC(reg);
WriteRawRC(reg, tmp & ~mask);  // clear bit mask
}

/////////////////////////////////////////////////////////////////////
//功能：通过RC522和ISO14443卡通讯
//参数说明：Command[IN]:RC522命令字
//       pInData[IN]:通过RC522发送到卡片的数据
//       InLenByte[IN]:发送数据的字节长度
//       pOutData[OUT]:接收到的卡片返回数据
//       *pOutLenBit[OUT]:返回数据的位长度
/////////////////////////////////////////////////////////////////////
char PcdComMF522(unsigned char Command,
               unsigned char *pInData,
               unsigned char InLenByte,
               unsigned char *pOutData,
               unsigned int  *pOutLenBit)
{
char status = MI_ERR;
unsigned char irqEn = 0x00;
unsigned char waitFor = 0x00;
unsigned char lastBits;
unsigned char n;
unsigned int i;
switch (Command)
{
   case PCD_AUTHENT:
      irqEn = 0x12;
      waitFor = 0x10;
      break;
   case PCD_TRANSCEIVE:
      irqEn = 0x77;
      waitFor = 0x30;
      break;
   default:
      break;
}

WriteRawRC(ComIEnReg,irqEn|0x80);
ClearBitMask(ComIrqReg,0x80);
WriteRawRC(CommandReg,PCD_IDLE);
SetBitMask(FIFOLevelReg,0x80);

for (i=0; i<InLenByte; i++)
{ WriteRawRC(FIFODataReg, pInData[i]); }
WriteRawRC(CommandReg, Command);

if (Command == PCD_TRANSCEIVE)
{ SetBitMask(BitFramingReg,0x80);  }

// i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
i = 2000;
do
{
      n = ReadRawRC(ComIrqReg);
      i--;
}
while ((i!=0) && !(n&0x01) && !(n&waitFor));
ClearBitMask(BitFramingReg,0x80);

if (i!=0)
{
      if(!(ReadRawRC(ErrorReg)&0x1B))
      {
         status = MI_OK;
         if (n & irqEn & 0x01)
         { status = MI_NOTAGERR; }
         if (Command == PCD_TRANSCEIVE)
         {
               n = ReadRawRC(FIFOLevelReg);
              lastBits = ReadRawRC(ControlReg) & 0x07;
            if (lastBits)
            { *pOutLenBit = (n-1)*8 + lastBits; }
            else
            { *pOutLenBit = n*8; }
            if (n == 0)
            { n = 1; }
            if (n > MAXRLEN)
            { n = MAXRLEN; }
            for (i=0; i<n; i++)
            { pOutData[i] = ReadRawRC(FIFODataReg); }
         }
      }
      else
      { status = MI_ERR; }

}

SetBitMask(ControlReg,0x80);          // stop timer now
WriteRawRC(CommandReg,PCD_IDLE);
return status;
}

/////////////////////////////////////////////////////////////////////
//开启天线
//每次启动或关闭天险发射之间应至少有1ms的间隔
/////////////////////////////////////////////////////////////////////
void PcdAntennaOn()
{
unsigned char i;
i = ReadRawRC(TxControlReg);
if (!(i & 0x03))
{
      SetBitMask(TxControlReg, 0x03);
}
}

/////////////////////////////////////////////////////////////////////
//关闭天线
/////////////////////////////////////////////////////////////////////
void PcdAntennaOff()
{
ClearBitMask(TxControlReg, 0x03);
}

//等待卡离开
void WaitCardOff(void)
{
char       status;
  unsigned char TagType[2];

while(1)
{
status = PcdRequest(REQ_ALL, TagType);
if(status)
{
status = PcdRequest(REQ_ALL, TagType);
if(status)
{
status = PcdRequest(REQ_ALL, TagType);
if(status)
{
return;
}
}
}
delay_10ms(100);
}
}

///////////////////////////////////////////////////////////////////////
// Delay 10ms
///////////////////////////////////////////////////////////////////////
void delay_10ms(unsigned int _10ms)
{
unsigned int i, j;

for(i=0; i<_10ms; i++)
{
delay_ms(10);
}
}
void MFRC522_GPIO_init(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure;

  GPIO_InitStructure.GPIO_Pin = MF522_RST_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(MF522_RST_PORT, &GPIO_InitStructure);

  /* Configure the GPIO pin */

  GPIO_InitStructure.GPIO_Pin = MF522_MISO_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(MF522_MISO_PORT, &GPIO_InitStructure);

  /* Configure the GPIO pin */
  GPIO_InitStructure.GPIO_Pin = MF522_MOSI_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(MF522_MOSI_PORT, &GPIO_InitStructure);

  /* Configure the GPIO pin */
  GPIO_InitStructure.GPIO_Pin = MF522_SCK_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(MF522_SCK_PORT, &GPIO_InitStructure);

  /* Configure the GPIO pin */
  GPIO_InitStructure.GPIO_Pin = MF522_NSS_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(MF522_NSS_PORT, &GPIO_InitStructure);

}
void MFRC522_init(void)//初始化模块
{
MFRC522_GPIO_init();

delay_10ms(10);
PcdReset(); //复位
PcdAntennaOff();  //关闭天线
PcdAntennaOn(); //开天线
M500PcdConfigISOType( 'A' ); //ISO14443_A工作方式

delay_10ms(10);

delay_10ms(10);

delay_10ms(10);

}

ID:472833 · 发表于 2019-1-25 14:42

int kahao(char src[], int start, int bit) {
strncpy(carNumber, src + start, bit);
ACCLOG("car_number:%s\n", carNumber);
return 0;
}

//获取卡的过期时间
int jieMika(char src[]) {
/*读卡解密部分 */
strncpy(overTime, src, 6);
ACCLOG("overTime:%s\n", overTime);
if (atoi(overTime) >= atoi(mostTime)) {
      return 1;
} else {
      return 0;
}
}

//判断卡的权限
int check_card(char src[],int n){
  for(int i=0;i<n;i++)
  {
   if(strncmp(src + (i * 3),community_pass,3)==0)
      return 1;
   if(strncmp(src + (i * 3),community_pass,3)!=0&&i==(n-1))
      return 0;
  }
}

//判断卡的权限
int check_carNumber(char src[]) {
char kami[5] = "";
strncpy(kami, src + (part * 4), 4);
ACCLOG("16numer:%s\n", kami);
memset((char *) &twoNumber, 0, sizeof(twoNumber));
for (int i = 0; i < 4; i++) {
      printhextobin(kami[i]);
}
ACCLOG("2number:%s\n", twoNumber);
int aa = atoi(swipe) - atoi(swipe) / 16 * 16;
char last[2] = "";
strncpy(last, twoNumber + (aa - 1), 1);
if (atoi(last) == 0) {
      return 1;
} else {
      return 0;
}
}

//读取卡的内容
int find_car_new(int sanqu)
{
int n=0,m=0,x=0,j,k,a = 0;
action=0;
char i;
char status;
if(!status){
      status = PcdRequest(REQ_ALL, TagType);//寻卡
      if(!status){
      status = PcdAnticoll(SelectedSnr);//防冲撞
      if(!status){
         status = PcdSelect(SelectedSnr);//选定卡片
         if(!status){
            status = PcdAuthState(KEYA, (sanqu * 4 + 0), DefaultKey[0], SelectedSnr);//验证卡片密码
            if(!status){
            status = PcdRead((sanqu * 4 + n), buf1);  //读取M1卡一块数据
            n++;
            if(!status){
               memset((char *) &car_str[0], 0, sizeof(car_str[0]));
               char tempChar[2];
               for (i = 0; i < 16; i++) {
                  int intNumber = (int) buf1[i];
                  sprintf(tempChar, "%x", intNumber);
                  int isZero = (int) tempChar[1];
                  if (isZero == 0) {
                  sprintf(&car_str[0][i * 2], "%s", "0");
                  car_str[0][i * 2 + 1] = tempChar[0];
                  } else {
                  car_str[0][i * 2] = tempChar[0];
                  car_str[0][i * 2 + 1] = tempChar[1];
                  }
               }
               ACCLOG("car_code1:%s\n", car_str[0]);
               status = PcdAuthState(KEYA, (sanqu * 4 + 0), DefaultKey[0], SelectedSnr);//验证卡片密码
               n++;
               if(!status){
                  status = PcdRead((sanqu * 4 + n), buf2);  //读取M1卡一块数据
                  memset((char *) &car_str[1], 0, sizeof(car_str[1]));
                  char tempChar[2];
                  for (i = 0; i < 16; i++) {
                  int intNumber = (int) buf2[i];
                  sprintf(tempChar, "%x", intNumber);
                  int isZero = (int) tempChar[1];
                  if (isZero == 0) {
                     sprintf(&car_str[1][i * 2], "%s", "0");
                     car_str[1][i * 2 + 1] = tempChar[0];
                  } else {
                     car_str[1][i * 2] = tempChar[0];
                     car_str[1][i * 2 + 1] = tempChar[1];
                  }
                  }
                  if(strncmp(car_str[1],"0000",4)!=0){
                  m=1;
                  ACCLOG("car_code2:%s\n", car_str[1]);
                  status = PcdAuthState(KEYA, (sanqu * 4 + 0), DefaultKey[0], SelectedSnr);//验证卡片密码
                  if(!status){
                     status = PcdRead((snr * 4 + n), buf3);  //读取M1卡一块数据
                     memset((char *) &car_str[2], 0, sizeof(car_str[2]));
                     char tempChar[2];
                     for (i = 0; i < 16; i++) {
                        int intNumber = (int) buf2[i];
                        sprintf(tempChar, "%x", intNumber);
                        int isZero = (int) tempChar[1];
                        if (isZero == 0) {
                        sprintf(&car_str[2][i * 2], "%s", "0");
                        car_str[2][i * 2 + 1] = tempChar[0];
                        } else {
                        car_str[2][i * 2] = tempChar[0];
                        car_str[2][i * 2 + 1] = tempChar[1];
                        }
                     }
                     if(strncmp(car_str[2],"0000",4)!=0){
                        m=2;
                        ACCLOG("car_code3:%s\n", car_str[2]);
                     }
                  }
                  }
                  if(jieMika(car_str[0])==1){
                  do{
                     for(j=0;j<=m;j++){
                        if(strncmp(car_str[j],"0000",4)!=0)
                        {
                        strncpy(quhao + (j * 4) + a * 4,car_str[j]+8,4);
                        strncpy(card_pass + (j * 3) + a * 3,car_str[j]+13,3);
                        x++;
                        if(strncmp(car_str[j]+16,"0000",4)!=0){
                           strncpy(quhao + ((j + 1) * 4) + a * 4,car_str[j]+24,4);
                           strncpy(card_pass + ((j + 1) * 3) + a * 3,car_str[j]+29,3);
                           x++;
                           if(j==m)
                              n=0;
                        }else
                           n=0;
                        }else{
                        n=0;
                        }
                        a++;
                     }
                  }while(n!=0);
                  if(strncmp(car_str[m]+8,community_num,4)==0){
                     if(strncmp(car_str[m]+12,"ffff",4)==0){
                        soundBee(1);
                        ACCLOG("this is universal_card...\n");
                        sendMessage(carNumber, 2);
                        car_return = 1;
                        action=1;
                        return 1;
                     }else if(check_card(card_pass,x)==1){
                        soundBee(1);
                        ACCLOG("open door...\n");
                        sendMessage(carNumber, 2);
                        car_return = 1;
                        action=1;
                        return 1;
                     }else{
                        soundBee(0);
                        ACCLOG("car has no power...\n");
                        sendMessage(carNumber, 6);
                        car_return = 3;
                        action=1;
                        return 3;
                     }
                  }else{
                     soundBee(0);
                     ACCLOG("not our community...\n");
                     sendMessage(carNumber, 6);
                     car_return = 3;
                     action=1;
                     return 3;
                  }
                  }else{
                  soundBee(0);
                  ACCLOG("card is overtiem...\n");
                  sendMessage(carNumber, 5);
                  car_return = 3;
                  action=1;
                  return 3;
                  }
               }
               ACCLOG("too fast...\n");
               soundBee(2);
               car_return = 5;
               return 5;
            }
            }
         }
      }
      }
}
car_return = 0;
return 0;
}

ID:1 · 发表于 2019-1-25 18:31

本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)

帐号		自动登录	找回密码
密码			立即注册

STM32与MFC522通信，IC卡读写

相关帖子