rc500.c

12232液晶单片机驱动程序源代码

          for(i=0;i<16;i++)   mdata[i]=MRcvBuffer[i];
      }
   }
 
   PcdSetTmo(2);               // short timeout   
   return status; 
}

/****************************************************************************
*                                                                           *
* Function:     mifs_write                                                  *
*                                                                           *
* Input:        Adr, Data                                                   *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/
char Mf500PiccWrite( unsigned char addr,
                  unsigned char *mdata)
{
   char status = MI_OK;
   char i;
   PcdSetTmo(4);     // long timeout 

   WriteRC(RegChannelRedundancy,0x0F); // RxCRC, TxCRC, Parity enable
     
     ResetInfo();   
     MSndBuffer[0] = PICC_WRITE;        // Write command code
     MSndBuffer[1] = addr;
     MInfo.nBytesToSend   = 2;
     status = PcdSingleResponseCmd(PCD_TRANSCEIVE);
/*
     if (status != MI_NOTAGERR)   // no timeout error   
     {
        if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
        {
           status = MI_BITCOUNTERR;
             printf("\n write erro 1 \n");   
        }
        else                     // 4 bit received
        {
           MRcvBuffer[0] &= 0x0f; // mask out upper nibble
           switch(MRcvBuffer[0])
           {
              case 0x00: 
                 status = MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status = MI_OK;
                 break;
              default:
                 status = MI_CODEERR;
                 break;
           }
        }
       
     }else if(status != MI_OK)   { return  status;   printf("\n write erro mi_notagerr 11 \n");   }
 */       
     if ( status == MI_OK)
     {
        PcdSetTmo(4);     // long timeout 
        ResetInfo();   
        //memcpy(MSndBuffer,mdata,16);
        for(i=0;i<16;i++)   MSndBuffer[i]=mdata[i];
        MInfo.nBytesToSend   = 16;
        status = PcdSingleResponseCmd(PCD_TRANSCEIVE);
   /*     
        if (status != MI_NOTAGERR)    // no timeout occured  
        {
           if (MInfo.nBitsReceived != 4)  // 4 bits are necessary
           {
              status = MI_BITCOUNTERR;
              printf("\n write erro 2 \n");
           }
           else                     // 4 bit received
           {
              MRcvBuffer[0] &= 0x0f; // mask out upper nibble
              switch(MRcvBuffer[0])
              {
                 case 0x00: 
                    status = MI_WRITEERR;
                    break;
                 case 0x0a:
                    status = MI_OK;
                    break;
                 default:
                    status = MI_CODEERR;
                    break;
              }
            }          
        }else { printf("\n write erro mi_notagerr 22 \n");   } 
*/
                       
        PcdSetTmo(2);    // short timeout
      }
         
  return status;
}

///////////////////////////////////////////////////////////////////////
//                V A L U E   M A N I P U L A T I O N 
///////////////////////////////////////////////////////////////////////
char Mf500PiccValue(unsigned char dd_mode, 
                   unsigned char addr, 
                   unsigned char *value,
                   unsigned char trans_addr)
{
   char status = MI_OK;
   char i;
   PcdSetTmo(2);
   ResetInfo();   
////1//////////////////////////////////////////////////////////////////
   MSndBuffer[0] = dd_mode;        // Inc,Dec command code
   MSndBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;
   status = PcdSingleResponseCmd(PCD_TRANSCEIVE);

   if (status != MI_NOTAGERR)   // no timeout error
   {
        if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
        {
           status = MI_BITCOUNTERR;
        }
        else                     // 4 bit received
        {
           MRcvBuffer[0] &= 0x0f; // mask out upper nibble
           switch(MRcvBuffer[0])
           {
              case 0x00: 
                 status = MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status = MI_OK;
                 break;
              case 0x01:
                 status = MI_VALERR;
                 break;
              default:
                 status = MI_CODEERR;
                 break;
           }
        }
   }  // else if(status != MI_OK) { return status;}

/////2///////////////////////////////////////////////////
     if ( status == MI_OK)
     {
        PcdSetTmo(4);     // long timeout 
        ResetInfo();   
        //memcpy(MSndBuffer,value,4);
        for(i=0;i<4;i++)   MSndBuffer[i]=value[i];
        MInfo.nBytesToSend   = 4;
        status = PcdSingleResponseCmd(PCD_TRANSCEIVE);
       
        
        if (status == MI_OK)    // no timeout occured
        {
            if (MInfo.nBitsReceived != 4)   //  bits are necessary
            {
               status = MI_BITCOUNTERR;
            }
            else                     // 4 bit received
            {
              
               MRcvBuffer[0] &= 0x0f; // mask out upper nibble
               switch(MRcvBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
               
              status = MI_OK;  ///////////////////////////////////////add

            }
         }                              
         else if(status == MI_NOTAGERR){

              status = MI_OK;  // no response after 4 byte value - 
                             // transfer command has to follow
           //   SendData("time out add value?");
         }
        // else { return  status;}
      }

/////3///////////////////////////////////////////////////////////

     if ( status == MI_OK)
     {
      //  SendData("how to run this");  //I  see
   //     PcdSetTmo(2);   /////////////////////////////////////////////
        ResetInfo();   
        MSndBuffer[0] = PICC_TRANSFER;        // transfer command code
        MSndBuffer[1] = trans_addr;
        MInfo.nBytesToSend   = 2;
        status = PcdSingleResponseCmd(PCD_TRANSCEIVE);
        
        if (status != MI_NOTAGERR)    // timeout occured
        {
            if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
            {
               status = MI_BITCOUNTERR;
            }
            else                     // 4 bit received
            {
               MRcvBuffer[0] &= 0x0f; // mask out upper nibble
              // switch(MRcvBuffer[0])
              // {
              //    case 0x00: 
              //       status = MI_NOTAUTHERR;
              //       break;
              //    case 0x0a:
                     status = MI_OK;
              //       break;
              //    case 0x01:
              //       status = MI_VALERR;
              //       break;
              //    default:
              //       status = MI_CODEERR;
              //       break;
              // }
            }
        }
     
           PcdSetTmo(2);    ////////////////////////////////////////////short timeout   
     } 

////////////////////////////////////////////////////////////
   return status;
}
/*

///////////////////////////////////////////////////////////////////////
//           V A L U E   MANIPULATION   W I T H   BACKUP  
///////////////////////////////////////////////////////////////////////
char Mf500PiccValueDebit(unsigned char dd_mode, 
                         unsigned char addr, 
                         unsigned char *value)
{
   char status = MI_OK;
   
   PcdSetTmo(2);
   ResetInfo();   
   MSndBuffer[0] = dd_mode;        // Inc,Dec command code
   MSndBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;
   status = PcdSingleResponseCmd(PCD_TRANSCEIVE);

   if (status != MI_NOTAGERR)   // no timeout error
   {
        if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
        {
           status = MI_BITCOUNTERR;
        }
        else                     // 4 bit received
        {
           MRcvBuffer[0] &= 0x0f; // mask out upper nibble
           switch(MRcvBuffer[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);     // long timeout 

        ResetInfo();   
        memcpy(MSndBuffer,value,4);
        MInfo.nBytesToSend   = 4;
        status = PcdSingleResponseCmd(PCD_TRANSCEIVE);
        
        if (status == MI_OK)    // no timeout occured
        {
            if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
            {
               status = MI_BITCOUNTERR;
            }
            else                     // 4 bit received
            {
               MRcvBuffer[0] &= 0x0f; // mask out upper nibble
               switch(MRcvBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x0a:
                     status = MI_OK;
                     break;
                  case 0x05:
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
            }
        }        
     }

   return status;
}
*/
/****************************************************************************
*                                                                           *
* Function:  Mf500PiccHalt                                                  *
*                                                                           *
* Input:        -                                                           *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/
char Mf500PiccHalt(void)
{
   char status = MI_CODEERR;

   PcdSetTmo(2);
   ResetInfo();   
   MSndBuffer[0] = PICC_HALT ;     // Halt command code
   MSndBuffer[1] = 0x00;         // dummy address
   MInfo.nBytesToSend   = 2;
   status = PcdSingleResponseCmd(PCD_TRANSCEIVE);