rc500.c

矿工定位系统单端

   {  
      case 1:                             // short timeout (1,0 ms)
         WriteRC(RegTimerClock,0x07);     // TAutoRestart=0,TPrescale=128
         WriteRC(RegTimerReload,0x6a);    // TReloadVal = 'h6a =106(dec)
         break;
      case 2:                             // medium timeout (1,5 ms)
         WriteRC(RegTimerClock,0x07);     // TAutoRestart=0,TPrescale=128
         WriteRC(RegTimerReload,0xa0);    // TReloadVal = 'ha0 =160(dec)
         break;
      case 3:                              // long timeout (6 ms)
         WriteRC(RegTimerClock,0x09);      // TAutoRestart=0,TPrescale=4*128
         WriteRC(RegTimerReload,0xa0);     // TReloadVal = 'ha0 =160(dec)
         break;
      case 4:                              // long timeout (9.6 ms)
         WriteRC(RegTimerClock,0x09);      // TAutoRestart=0,TPrescale=4*128
         WriteRC(RegTimerReload,0xff);     // TReloadVal = 'ff =255(dec)
         break;
      default:                             // short timeout (1,0 ms)
         WriteRC(RegTimerClock,0x07);      // TAutoRestart=0,TPrescale=128
         WriteRC(RegTimerReload,tmoLength);// TReloadVal = tmoLength
         break;
   }
   WriteRC(RegTimerControl,0X06);
}
//*********************************************************
extern char PcdWrite(uchar addr,uchar *writedata)
{
    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_WRITE;
    MfComData.MfData[1]=addr;

    status=PcdComTransceive(pi);
    if(status!=MI_NOTAGERR)
    {
        if(MfComData.MfLength!=4)
        {
           status=MI_BITCOUNTERR;
        }
        else
        {
           MfComData.MfData[0]&=0x0f;
           switch(MfComData.MfData[0])
           {
              case 0x00:
                 status=MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status=MI_OK;
                 break;
              default:
                 status=MI_CODEERR;
                 break;
           }
        }
     }
     if(status==MI_OK)
     {
        PcdSetTmo(3);
        MfComData.MfCommand=PCD_TRANSCEIVE;
        MfComData.MfLength=16;
        for(i=0;i<16;i++)
        {
            MfComData.MfData[i]=*(writedata+i);
        }
        status=PcdComTransceive(pi);
        if(status!=MI_NOTAGERR)
        {
            MfComData.MfData[0]&=0x0f;
            switch(MfComData.MfData[0])
            {
               case 0x00:
                  status=MI_WRITEERR;
                  break;
               case 0x0a:
                  status=MI_OK;
                  break;
               default:
                  status=MI_CODEERR;
                  break;
           }
        }
     }
  return status;
}
//*************************************************************
/*****************************************************************************
*          复位并初始化RC500
*注意:RC500上电后应延时500ms才能可靠初始化
******************************************************************************/
char PcdReset()
{
   char status=MI_OK;
   char n=0;
   uint i=0x4000;

   RC500_RST=1;
   DelayMs(100);
   RC500_RST=0;
   while(i!=0&&n!=0x3f)
   {
      n=ReadRawRC(RegCommand);
      i--;
   }
   while(i!=0&&n==0x3f)
   {
      n=ReadRawRC(RegCommand);
      i--;
   }
   if(i!=0)
   {
      WriteRawRC(RegPage,0x80);
      n=0x80;
      while((i!=0)&&(n&0x80))
      {
          n=ReadRawRC(RegCommand);
          i--;
      }
      if(i==0||(n&0xff))
      {
          status=MI_RESETERR;
      }
   }
   else
   {
       status=MI_RESETERR;
   }
   if(status==MI_OK)
   {
     WriteRC(RegClockQControl,0x0);
     WriteRC(RegClockQControl,0x40);
     DelayUs(100);
     ClearBitMask(RegClockQControl,0x40);
     WriteRC(RegBitPhase,0xad);
     WriteRC(RegRxThreshold,0xff);
     WriteRC(RegRxControl2,01);
     WriteRC(RegFIFOLevel,0x1a);
     WriteRC(RegTimerControl,0x02);
     WriteRC(RegIRqPinConfig,0x02);
     WriteRC(RegTxControl,0x5b);
   }
   return status;
}

/*****************************************************************************
*         延时
*****************************************************************************/
void DelayMS(uchar j)
{
   uchar i,n;
   for(i=0;i<j;i++)
   {   for(n=0;n<230;n++);
   }
}
void DelayUs(uchar j)
{
   uchar i,n;
   n=j/5;
   for(i=0;i<n;i++);
}
//**********************************************************************
uchar ReadRawRC(uchar Address)
{
  /* uchar pdata *pa;
   pa=Address;//+Base_addr;
   return(*pa);*/
   uchar xdata *pa;
   pa=Address+Base_addr;
   return(*pa);

}
//**************************************************
uchar ReadRC(uchar Address)
{
   /*uchar pdata *pa;
   pa=RegPage;
   *pa=Address>>3;
   pa=Address;
   return(*pa);*/

    uchar xdata *pa;
	 pa=Base_addr;
   *pa=Address>>3;
   pa=Address+Base_addr;
   return(*pa);
}
//***********************************************
void SetBitMask(uchar reg,uchar mask)
{
   char tmp=0x0;
   tmp=ReadRC(reg);
   WriteRC(reg,tmp|mask);
}
//************************************************
void WriteRawRC(uchar Address,uchar value)
{
   /*uchar pdata *pa;
   pa=Address+Base_addr;
   *pa=value;*/
   uchar xdata *pa;
   pa=Address+Base_addr;
   *pa=value;
}
//**************************************************
char ChangeCodeKey(uchar *uncoded,uchar *coded)
{
   uchar idata cnt=0;
   uchar idata ln=0;
   uchar idata hn=0;

   for(cnt=0;cnt<6;cnt++)
   {
      ln=uncoded[cnt]&0x0F;
      hn=uncoded[cnt]>>4;
      coded[cnt*2+1]=(~ln<<4)|ln;
      coded[cnt*2]=(~hn<<4)|hn;
   }
   return MI_OK;
}
//***************************************************
char PcdHalt(void)
{
    char status=MI_OK;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[2];
                                }MfComData;
    struct TranSciveBuffer *pi;
    pi=&MfComData;

    PcdSetTmo(106);
    MfComData.MfCommand=PCD_TRANSCEIVE;
    MfComData.MfLength=2;
    MfComData.MfData[0]=PICC_HALT;
    MfComData.MfData[1]=0;

    status=PcdComTransceive(pi);
    if (status)
    {
        if(status==MI_NOTAGERR||status==MI_ACCESSTIMEOUT)
        status = MI_OK;
    }
    WriteRC(RegCommand,PCD_IDLE);
    return status;
}
/********************************************************
char PcdValue(uchar dd_mode,uchar addr,uchar *value)
{
    char status;
    uchar i;
    idata struct TranSciveBuffer{uchar MfCommand;
                                 uchar MfLength;
                                 uchar MfData[4];
                                }MfComData;
    struct TranSciveBuffer *pi;
    pi=&MfComData;

    PcdSetTmo(106);
    MfComData.MfCommand=PCD_TRANSCEIVE;
    MfComData.MfLength=2;
    MfComData.MfData[0]=dd_mode;
    MfComData.MfData[1]=addr;

    status=PcdComTransceive(pi);
    if(status!=MI_NOTAGERR)
    {
        if(MfComData.MfLength!=4)
        {
           status=MI_BITCOUNTERR;
        }
        else
        {
           MfComData.MfData[0]&=0x0f;
           switch(MfComData.MfData[0])
           {
              case 0x00:
                 status=MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status=MI_OK;
                 break;
              case 0x01:
                 status=MI_VALERR;
                 break;
              default:
                 status=MI_CODEERR;
                 break;
           }
        }
     }
     if(status==MI_OK)
     {
        PcdSetTmo(4);
        MfComData.MfCommand=PCD_TRANSCEIVE;
        MfComData.MfLength=4;
        pi=&MfComData;
        for(i=0;i<4;i++)
        {
            MfComData.MfData[i]=*(value+i);
        }
        status=PcdComTransceive(pi);
        if(status==MI_OK||status==MI_NOTAGERR)
        {
           if(MfComData.MfLength!=4)
           {
              status = MI_BITCOUNTERR;
           }
           else
           {
              status=MI_OK;
            }
         }
         else
         {
              status=MI_COM_ERR;
          }
     }
     if(status==MI_OK)
     {
        MfComData.MfCommand=PCD_TRANSCEIVE;
        MfComData.MfLength=2;
        MfComData.MfData[0]=PICC_TRANSFER;
        MfComData.MfData[1]=addr;
        status=PcdComTransceive(pi);
        if(status!=MI_NOTAGERR)
        {
            if(MfComData.MfLength!=4)
            {
               status=MI_BITCOUNTERR;
            }
            else
            {
               MfComData.MfData[0]&=0x0f;
               switch(MfComData.MfData[0])
               {
                  case 0x00:
                     status=MI_NOTAUTHERR;
                     break;
                  case 0x0a:
                     status=MI_OK;
                     break;
                  case 0x01:
                     status=MI_VALERR;
                     break;
                  default:
                     status=MI_CODEERR;
                     break;
               }
            }
        }
     }
   return status;
}*/