rc500.c

矿工定位系统单端

//#include<reg52.h>
#include "REG51F.H"
#include<rc500.h>
//sbit RC500_RST=P4^2;  
sbit RC500_RST=P3^5;      
idata struct TranSciveBuffer{uchar MfCommand;
                             uchar MfLength;
                             uchar MfData[19];
                            };
//*********************************************************************
void WriteRC(uchar Address,uchar value)
{
 /* uchar pdata *pa;
   pa=RegPage;
   *pa=Address>>3;
   pa=Address;
   *pa=value;*/
    uchar xdata *pa;
   pa=Base_addr;
   *pa=Address>>3;
   pa=Address+Base_addr;
   *pa=value;
   
}
//***************************************************
void ClearBitMask(uchar reg,uchar mask)
{
   char tmp=0x0;
   tmp = ReadRC(reg);
   WriteRC(reg,tmp & ~mask);
}
//********************************************************
char PcdAnticoll(uchar *snr)
{
    uchar i;
    uchar snr_check=0;
    char status=MI_OK;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[5];
                                }MfComData;
    struct TranSciveBuffer *pi;

    pi=&MfComData;
    PcdSetTmo(106);
    WriteRC(RegDecoderControl,0x28);
    ClearBitMask(RegControl,0x08);
    WriteRC(RegChannelRedundancy,0x03);

    MfComData.MfCommand=PCD_TRANSCEIVE;
    MfComData.MfLength=2;
    MfComData.MfData[0]=PICC_ANTICOLL1;
    MfComData.MfData[1]=0x20;
    status=PcdComTransceive(pi);
    if(!status)
    {
    	 for(i=0;i<4;i++)
         {
             snr_check^=MfComData.MfData[i];
         }
         if(snr_check!=MfComData.MfData[i])
         {
             status=MI_SERNRERR;
         }
         else
         {
             for(i=0;i<4;i++)
             {
             	*(snr+i)=MfComData.MfData[i];
             }
         }

    }
    ClearBitMask(RegDecoderControl,0x20);
    return status;
}
//**************************************************************
char PcdAuthKey(uchar *keys)
{
    char status;
    uchar i;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[12];
                                }MfComData;
    struct TranSciveBuffer *pi;
    pi=&MfComData;
    PcdSetTmo(106);
    MfComData.MfCommand=PCD_LOADKEY;
    MfComData.MfLength=12;
    for(i=0;i<12;i++)
    {
        MfComData.MfData[i]=*(keys+i);
    }
    status=PcdComTransceive(pi);
    return status;
}
//*************************************************************
char PcdAuthState(uchar auth_mode,uchar block,uchar *snr)
{
    char status=MI_OK;
    uchar i;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[6];
                                }MfComData;
    struct TranSciveBuffer *pi;
    pi=&MfComData;

    WriteRC(RegChannelRedundancy,0x07);
    if(status==MI_OK)
    {
        PcdSetTmo(106);
        MfComData.MfCommand=PCD_AUTHENT1;
        MfComData.MfLength=6;
        MfComData.MfData[0]=auth_mode;
        MfComData.MfData[1]=block;
        for(i=0;i<4;i++)
        {
	      MfComData.MfData[i+2]=*(snr+i);
        }
        if((status=PcdComTransceive(pi))==MI_OK)
        {
            if (ReadRC(RegSecondaryStatus)&0x07) 
            {
                status = MI_BITCOUNTERR;
            }
            else
            {
                MfComData.MfCommand=PCD_AUTHENT2;
                MfComData.MfLength=0;
                if((status=PcdComTransceive(pi))==MI_OK)
                {
                    if(ReadRC(RegControl)&0x08)
                        status=MI_OK;
                    else
                        status=MI_AUTHERR;
                }
             }
         }
   }
   return status;
}
//***************************************


char PcdComTransceive(struct TranSciveBuffer *pi)
{
   bit recebyte=0;
   char status;
   uchar irqEn=0x00;
   uchar waitFor=0x00;
   uchar lastBits;
   uchar n;
   uint i;
   switch(pi->MfCommand)
   {
      case PCD_IDLE:
         irqEn = 0x00;
         waitFor = 0x00;
         break;
      case PCD_WRITEE2:
         irqEn = 0x11;
         waitFor = 0x10;
         break;
      case PCD_READE2:
         irqEn = 0x07;
         waitFor = 0x04;
         recebyte=1;
         break;
      case PCD_LOADCONFIG:
      case PCD_LOADKEYE2:
      case PCD_AUTHENT1:
         irqEn = 0x05;
         waitFor = 0x04;
         break;
      case PCD_CALCCRC:
         irqEn = 0x11;
         waitFor = 0x10;
         break;
      case PCD_AUTHENT2:
         irqEn = 0x04;
         waitFor = 0x04;
         break;
      case PCD_RECEIVE:
         irqEn = 0x06;
         waitFor = 0x04;
         recebyte=1;
         break;
      case PCD_LOADKEY:
         irqEn = 0x05;
         waitFor = 0x04;
         break;
      case PCD_TRANSMIT:
         irqEn = 0x05;
         waitFor = 0x04;
         break;
      case PCD_TRANSCEIVE:
         irqEn = 0x3D;
         waitFor = 0x04;
         recebyte=1;
         break;
      default:
         pi->MfCommand=MI_UNKNOWN_COMMAND;
         break;
   }
   if(pi->MfCommand!=MI_UNKNOWN_COMMAND)
   {
      WriteRC(RegPage,0x00);
      WriteRC(RegInterruptEn,0x7F);
      WriteRC(RegInterruptRq,0x7F);
      WriteRC(RegCommand,PCD_IDLE);
      SetBitMask(RegControl,0x01);
      WriteRC(RegInterruptEn,irqEn|0x80);
      for(i=0;i<pi->MfLength;i++)
      {
         WriteRC(RegFIFOData,pi->MfData[i]);
      }
      WriteRC(RegCommand,pi->MfCommand);
      i=0x2000;
      do
      {
         n=ReadRC(RegInterruptRq);
         i--;
      }
      while((i!=0)&&!(n&irqEn&0x20)&&!(n&waitFor));
      status=MI_COM_ERR;
      if((i!=0)&&!(n&irqEn&0x20))
      {
         if(!(ReadRC(RegErrorFlag)&0x17))
         {
            status=MI_OK;
            if(recebyte)
            {
              	n=ReadRC(RegFIFOLength);
              	lastBits=ReadRC(RegSecondaryStatus)&0x07;
                if(lastBits)
                {
                   pi->MfLength=(n-1)*8+lastBits;
                }
                else
                {
                   pi->MfLength=n*8;
                }
                if(n==0)
                {
                   n=1;
                }
                for(i=0;i<n;i++)
                {
                      pi->MfData[i]=ReadRC(RegFIFOData);
                }
            }
         }
      }
      else if(n&irqEn&0x20)
      {
          status=MI_NOTAGERR;
      }
      else
      {
          status=MI_COM_ERR;
      }
      WriteRC(RegInterruptEn,0x7F);
      WriteRC(RegInterruptRq,0x7F);
   }
   return status;
}
//*************************************************
char PcdRead(uchar addr,uchar *readdata)
{
    char status;
    uchar i;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[16];
                                }MfComData;
    struct TranSciveBuffer *pi;

    pi=&MfComData;
    PcdSetTmo(4);
    WriteRC(RegChannelRedundancy,0x0F);
    MfComData.MfCommand=PCD_TRANSCEIVE;
    MfComData.MfLength=2;
    MfComData.MfData[0]=PICC_READ;
    MfComData.MfData[1]=addr;

    status=PcdComTransceive(pi);
    if(status==MI_OK)
    {
        if(MfComData.MfLength!=0x80)
        {
            status = MI_BITCOUNTERR;
        }
        else
        {
            for(i=0;i<16;i++)
            {
                *(readdata+i)=MfComData.MfData[i];
            }
        }
    }
    return status;
}
//*******************************************************************
char PcdRequest(uchar req_code)
{
   char status;
   idata struct TranSciveBuffer {uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[1];
                                }MfComData;
   struct TranSciveBuffer *pi;

   pi=&MfComData;
   PcdSetTmo(106);
   WriteRC(RegChannelRedundancy,0x03);
   ClearBitMask(RegControl,0x08);
   WriteRC(RegBitFraming,0x07);
   MfComData.MfCommand=PCD_TRANSCEIVE;
   MfComData.MfLength=1;
   MfComData.MfData[0]=req_code;
   status=PcdComTransceive(pi);
   if(!status)
   {    if(MfComData.MfLength!=0x10)
        {
         status=MI_BITCOUNTERR;
        }
   }
   return status;
}
//****************************************************************************
char PcdSelect(uchar *snr)
{
    uchar i;
    char status;
    uchar snr_check=0;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[7];
                                }MfComData;
    struct TranSciveBuffer *pi;

    pi=&MfComData;
    PcdSetTmo(106);
    WriteRC(RegChannelRedundancy,0x0F);
    ClearBitMask(RegControl,0x08);

    MfComData.MfCommand=PCD_TRANSCEIVE;
    MfComData.MfLength=7;
    MfComData.MfData[0]=PICC_ANTICOLL1;
    MfComData.MfData[1]=0x70;
    for(i=0;i<4;i++)
    {
    	snr_check^=*(snr+i);
    	MfComData.MfData[i+2]=*(snr+i);
    }
    MfComData.MfData[6]=snr_check;
    status=PcdComTransceive(pi);
    if(status==MI_OK)
    {    if(MfComData.MfLength!=0x8)
        {
         status = MI_BITCOUNTERR;
        }
   }
   return status;
}
//************************************************************************
void PcdSetTmo(uchar tmoLength)
{
   switch(tmoLength)