⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 rc500.lst

📁 基于RC500射频卡读写模块的程序设计
💻 LST
📖 第 1 页 / 共 5 页
字号:
 945   1         return MI_OK;
 946   1      }
 947          
 948          ///////////////////////////////////////////////////////////////////////
 949          //          W R I T E   R E G I S T E R 
 950          ///////////////////////////////////////////////////////////////////////
 951          char M500PcdWriteRegister(unsigned char Reg, unsigned char value)
 952          {
 953   1         WriteIO(Reg,value);
 954   1       TOGGLE_WD();
 955   1         return MI_OK;
 956   1      }
 957          
 958          ///////////////////////////////////////////////////////////////////////
 959          //          R E A D   R E G I S T E R 
 960          ///////////////////////////////////////////////////////////////////////
 961          char M500PcdReadRegister(unsigned char Reg)
 962          {
 963   1         char value;
 964   1       TOGGLE_WD();   
 965   1         value = ReadIO(Reg);
 966   1         return (value);
 967   1      }
 968              
 969          ///////////////////////////////////////////////////////////////////////
 970          //          M I F A R E    R E Q U E S T 
 971          ///////////////////////////////////////////////////////////////////////
 972          char M500PiccRequest(unsigned char req_code, // request code ALL = 0x52 
 973                                                       // or IDLE = 0x26 
 974                             unsigned char *atq)     // answer to request
 975          {
 976   1         return M500PiccCommonRequest(req_code,atq);
 977   1      }
 978          
 979          ///////////////////////////////////////////////////////////////////////
 980          //          M I F A R E   C O M M O N   R E Q U E S T 
 981          ///////////////////////////////////////////////////////////////////////
 982          char M500PiccCommonRequest(unsigned char req_code, 
 983                                   unsigned char *atq)
 984          {
C51 COMPILER V7.20   RC500                                                                 02/04/2007 10:44:17 PAGE 17  

 985   1         char idata status = MI_OK;
 986   1       TOGGLE_WD();
 987   1          //************* initialize ******************************
 988   1         WriteIO(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
 989   1         ClearBitMask(RegControl,0x08);    // disable crypto 1 unit   
 990   1         WriteIO(RegBitFraming,0x07);        // set TxLastBits to 7 
 991   1         SetBitMask(RegTxControl,0x03);    // Tx2RF-En, Tx1RF-En enable
 992   1         
 993   1         ResetInfo(MInfo);   
 994   1         MSndBuffer[0] = req_code;
 995   1         MInfo.nBytesToSend   = 1;   
 996   1         status = M500PcdCmd(PCD_TRANSCEIVE,
 997   1                            MSndBuffer,
 998   1                            MRcvBuffer,
 999   1                            &MInfo);
1000   1        
1001   1         if (status)      // error occured
1002   1         {
1003   2            *atq = 0;
1004   2         } 
1005   1         else 
1006   1         {
1007   2            if (MInfo.nBitsReceived != 16) // 2 bytes expected
1008   2            {
1009   3               *atq = 0;
1010   3               status = MI_BITCOUNTERR;
1011   3            } 
1012   2            else 
1013   2            {
1014   3               status = MI_OK;
1015   3               memcpy(atq,MRcvBuffer,2);
1016   3            }
1017   2         }
1018   1       TOGGLE_WD();
1019   1         return status; 
1020   1      }
1021          
1022          ///////////////////////////////////////////////////////////////////////
1023          //          M I F A R E    A N T I C O L L I S I O N
1024          // for standard select
1025          ///////////////////////////////////////////////////////////////////////
1026          char M500PiccAnticoll (unsigned char bcnt,
1027                               unsigned char *snr)
1028          {
1029   1         return M500PiccCascAnticoll(0x93,bcnt,snr); // first cascade level
1030   1      }
1031          
1032          ///////////////////////////////////////////////////////////////////////
1033          //          M I F A R E    A N T I C O L L I S I O N
1034          // for extended serial numbers
1035          ///////////////////////////////////////////////////////////////////////
1036          char M500PiccCascAnticoll (unsigned char select_code,
1037                                     unsigned char bcnt,       
1038                                     unsigned char *snr)       
1039          {
1040   1         char idata status = MI_OK;
1041   1         char idata snr_in[4];     // copy of the input parameter snr
1042   1         char idata nbytes = 0;
1043   1         char idata nbits = 0;
1044   1         char idata complete = 0;
1045   1         char idata i        = 0;
1046   1         char idata byteOffset = 0;
C51 COMPILER V7.20   RC500                                                                 02/04/2007 10:44:17 PAGE 18  

1047   1         unsigned char idata snr_crc;
1048   1         unsigned char idata snr_check;
1049   1         unsigned char dummyShift1;       // dummy byte for snr shift
1050   1         unsigned char dummyShift2;       // dummy byte for snr shift   
1051   1       TOGGLE_WD(); 
1052   1         //************* Initialisation ******************************
1053   1         M500PcdSetTmo(106);
1054   1         memcpy(snr_in,snr,4);   
1055   1         
1056   1         WriteIO(RegDecoderControl,0x28); // ZeroAfterColl aktivieren   
1057   1         ClearBitMask(RegControl,0x08);    // disable crypto 1 unit
1058   1            
1059   1         //************** Anticollision Loop ***************************
1060   1         complete = 0;
1061   1      //   bcnt = 0;   // no part of the snr is known
1062   1         while (!complete && (status == MI_OK) )
1063   1         { TOGGLE_WD();
1064   2            ResetInfo(MInfo);           
1065   2            WriteIO(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
1066   2            nbits = bcnt % 8;   // remaining number of bits
1067   2            if (nbits)
1068   2            {
1069   3               WriteIO(RegBitFraming,nbits << 4 | nbits); // TxLastBits/RxAlign auf nb_bi
1070   3               nbytes = bcnt / 8 + 1;   
1071   3               // number of bytes known
1072   3      
1073   3               // in order to solve an inconsistancy in the anticollision sequence
1074   3               // (will be solved soon), the case of 7 bits has to be treated in a
1075   3               // separate way - please note the errata sheet
1076   3               if (nbits == 7)
1077   3               {
1078   4                  MInfo.cmd = PICC_ANTICOLL1;   // pass command flag to ISR        
1079   4                  WriteIO(RegBitFraming,nbits); // reset RxAlign to zero
1080   4               }
1081   3            } 
1082   2            else
1083   2            {
1084   3               nbytes = bcnt / 8;
1085   3            }
1086   2      
1087   2            MSndBuffer[0] = select_code;
1088   2            MSndBuffer[1] = 0x20 + ((bcnt/8) << 4) + nbits; //number of bytes send
1089   2                     
1090   2            for (i = 0; i < nbytes; i++)  // Sende Buffer beschreiben
1091   2            {
1092   3               MSndBuffer[i + 2] = snr_in[i];
1093   3            }
1094   2            MInfo.nBytesToSend   = 2 + nbytes;   
1095   2       
1096   2            status = M500PcdCmd(PCD_TRANSCEIVE,
1097   2                               MSndBuffer,
1098   2                               MRcvBuffer,
1099   2                               &MInfo);
1100   2         
1101   2          
1102   2            // in order to solve an inconsistancy in the anticollision sequence
1103   2            // (will be solved soon), the case of 7 bits has to be treated in a
1104   2            // separate way 
1105   2            if (nbits == 7)
1106   2            {
1107   3               // reorder received bits
1108   3               dummyShift1 = 0x00;
C51 COMPILER V7.20   RC500                                                                 02/04/2007 10:44:17 PAGE 19  

1109   3               for (i = 0; i < MInfo.nBytesReceived; i++)
1110   3               {
1111   4                  dummyShift2 = MRcvBuffer[i];
1112   4                  MRcvBuffer[i] = (dummyShift1 >> (i+1)) | (MRcvBuffer[i] << (7-i));
1113   4                  dummyShift1 = dummyShift2;
1114   4               }
1115   3               MInfo.nBitsReceived -= MInfo.nBytesReceived; // subtract received parity bits
1116   3               // recalculation of collision position
1117   3               if ( MInfo.collPos ) MInfo.collPos += 7 - (MInfo.collPos + 6) / 9;
1118   3            }
1119   2               
1120   2            if ( status == MI_OK || status == MI_COLLERR)    // no other occured
1121   2            {
1122   3               // R e s p o n s e   P r o c e s s i n g   
1123   3               if ( MInfo.nBitsReceived != (40 - bcnt) ) // not 5 bytes answered
1124   3               {
1125   4                  status = MI_BITCOUNTERR; // Exit with error
1126   4               } 
1127   3               else 
1128   3               {
1129   4                  byteOffset = 0;
1130   4                  if( nbits != 0 ) // last byte was not complete
1131   4                  {
1132   5                      snr_in[nbytes - 1] = snr_in[nbytes - 1] | MRcvBuffer[0];
1133   5                      byteOffset = 1;
1134   5                  }
1135   4      
1136   4                  for ( i =0; i < (4 - nbytes); i++)     
1137   4                  {
1138   5                     snr_in[nbytes + i] = MRcvBuffer[i + byteOffset];
1139   5                  }
1140   4        
1141   4                  if (status != MI_COLLERR ) // no error and no collision
1142   4                  {
1143   5                     // SerCh check
1144   5                     snr_crc = snr_in[0] ^ snr_in[1] ^ snr_in[2] ^ snr_in[3];
1145   5                     snr_check = MRcvBuffer[MInfo.nBytesReceived - 1];
1146   5                     if (snr_crc != snr_check)
1147   5                     {
1148   6                        status = MI_SERNRERR;
1149   6                     } 
1150   5                     else   
1151   5                     {
1152   6                        complete = 1;
1153   6                     }
1154   5                  }
1155   4                  else                   // collision occured
1156   4                  {
1157   5                     bcnt = bcnt + MInfo.collPos - nbits;
1158   5                     status = MI_OK;
1159   5                  }
1160   4               }
1161   3            }
1162   2         }
1163   1         if (status == MI_OK)
1164   1         {
1165   2            // transfer snr_in to snr
1166   2            memcpy(snr,snr_in,4);
1167   2         }
1168   1         else
1169   1         {
1170   2            memcpy(snr,"0000",4);
C51 COMPILER V7.20   RC500                                                                 02/04/2007 10:44:17 PAGE 20  

1171   2         }
1172   1      
1173   1         //----------------------Einstellungen aus Initialisierung ruecksetzen 
1174   1         ClearBitMask(RegDecoderControl,0x20); // ZeroAfterColl disable
1175   1       TOGGLE_WD();   
1176   1         return status;  
1177   1      }
1178          
1179          ///////////////////////////////////////////////////////////////////////
1180          //          M I F A R E    S E L E C T 
1181          // for 

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -