设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › FM1702与单片机读卡写卡通讯程序源码+说明+注意事项+资 ...
返回列表 发新帖
查看: 4757|回复: 3
收起左侧

FM1702与单片机读卡写卡通讯程序源码+说明+注意事项+资料下载

[复制链接]
ID:158588 发表于 2018-11-5 21:03 | 显示全部楼层 |阅读模式
51单片机驱动FM1702实现读写卡的资料包分享：
0.png

FM1702天线设计与电路设计及编程指南等：
0.png


程序使用说明：
1.程序用到的数码管、FM1702、按键的所有引脚均有定义，如果用户按照这个定义，程序上电后应该是数  码管无显示内容。
2.当有卡片靠近后，数码管先显示卡号序列号的高两位，显示大约2秒，然后读取卡片的块8的数值并显示
  显示时间大约为6秒
3.按键是双功能键。按键2和3是充值和刷卡键，4是确认键，只有先按2或者3然后按4，否则直接按4程序  不会反应。当按了4后，此时按键2和3就变成增值或者减值按键，同时短按一下是增1或者减1，长按是  增10或者减10.确认了数值后，再次按4键，程序会根据你按得是充值键还是刷卡键进行响应的加或减运  算，并将运算后得值写入块8，然后再次读取，并显示在数码管上。在你按键确认数值之前，数码管会  显示当前你的按键值是多少。
4.总结使用流程就是：放卡到读卡器—按动2或3键—按4—再按2或3（长按短按效果不一样，数码管会显  示）—再按4—卡拿开


不足之处：
1.没有用到芯片自带的E2PROM，所以程序没有它的读写程序。
2.没有用到卡的自增自减运算函数，这个涉及卡的控制字符，卡的资料有详细，所以也没写
3.防衝突没有实现那种公平的防衝突，此程序实现的是随机选卡


注意事项：
网上关于射频卡的资料很多关键的地方都没有说明，类似SPI时序，寄存器读写指令，FIFO读写时间等等，所以下列几点一定要注意，这是我在做这个时遇到的问题。
1.首先，spi时序，注意读时和写时的sck，以及左移函数的位置，很重要。也可以把SPI的读和写分开写  ，会的自己试一下。
2.1702的寄存器读写并不是单纯的把寄存器地址写进去，而是有一定规则的。不论读写，寄存器都是先左  移一位，即有效的六位地址（做的时候你就明白为什麽是六位）处于一个字节的中间，最低位不论读写  都为0，高位当读时是1，写时是0，这点非常重要，查遍所有资料，都没有这点。
3.1702初始化时，按照pdf所给的启动步骤来，当时我觉得最后一条转换线性寻址好像没用到，所以没写  ，结果怎麽也不好使，后来一加，什麽都好使了。这也是很关键的一点。
4.延时问题，当FIFO有数据要发送或者接受时，启动0x1e命令后，根据FIFO字节数要加适当延时，这是很  关键的点，具体参考程序。


   大致就这些了，程序实现的功能比较简单，后续我也许会加上12864，做成一个界面化的带密码修改，以及卡的识别的小型一卡通系统，类似于学校那种什麽饭卡、交通、图书馆、水卡的东西，如果做的话，我会把后续的传上来。敬请期待....


51单片机源程序如下:

  2. #include<reg52.h>
  3. #include<intrins.h>
  4. #include<FM1702.h>
  5. #define uchar  unsigned char
  6. #define uint   unsigned int

  8. uchar Fbuff[16];                               //发送FIFO缓存
  9. uchar Jbuff[16];                              //接收FIFO缓存
  10. uchar UID[7];                                      //卡型及卡号
  11. uchar Data[4];                                  //按键值存储区
  12. uchar code  seg[16]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E}; //数码管段选对应0~f
  13. uchar count=0           ;                         //按键回传的值
  14. uchar shuaka,chongzhi,keyflag=0;
  15. sbit k2=P3^5;                                         //充值‘加值键（实现加1或者加10）
  16. sbit k3=P3^2;                                         //刷卡’减值键（实现减1或者减10）
  17. sbit k4=P3^3;                                       //确认键
  18. sbit nWR=P2^4;                                      //74hc373片选
  19. /*****************1702函数声明**************************/
  20. uchar spi(uchar m);
  21. void  fifo_clear();
  22. void  resig_write(uchar reg,uchar da);
  23. uchar resig_read(uchar reg);
  24. uchar  fifo_read(uchar count,uchar *s);
  25. void  fifo_write(uchar count,uchar *s);
  26. uchar inti_1702();
  27. void  card_halt();
  28. uchar request();
  29. uchar card_anticoll();
  30. uchar card_select();
  31. uchar card_authtication(uchar m)         ;
  32. uchar card_read(uchar m);
  33. uchar card_write(uchar m);
  34. uchar loadkey();
  35. void  delay(uchar m);
  36. /********************按键显示函数声明***************/

  38. void display();
  39. void keyscan() ;
  40. void  data1deal() ;
  41. void  data2deal(uchar m);
  42. void lcdclear();
  43. /***********************子函数解释******************/
  44. /*********************************************************/
  45. //解释： 这是spi总线的读写时序，所有的寄存器操作基于此时序，非常重要
  46. //
  47. //
  48. //输入：要写入的16进制参数
  49. //
  50. //
  51. //输出：内部传回的16进制参数
  52. //
  53. /********************************************************/
  54. uchar spi(uchar m)
  55. {
  56.         uchar i,temp=0;
  57.         for(i=0;i<8;i++)
  58.         {
  59.                 sck=0;
  60.                 if(m&0x80)
  61.                 mosi=1;
  62.                 else
  63.                 mosi=0;
  64.                 m<<=1;
  65.                 sck=1;
  66.                 temp<<=1;
  67.                 if(miso)
  68.                 temp|=0x01;

  70.         }
  71.         sck=0;
  72.         mosi=0;
  73.         return  temp;
  74. }
  75. /*********************************************************/
  76. //解释：写寄存器函数
  77. //
  78. //
  79. //输入：寄存器地址 以及要写入的参数
  80. //
  81. //
  82. //输出：
  83. //
  84. //注意！！在所有的资料中都没有给出寄存器寻址时的格式，下边的有，看仔细了，如果连寄存器都找不到，后边的就不用看了
  85. /********************************************************/
  86. void resig_write(uchar reg,uchar da)
  87. {
  88.         sck=0;
  89.         reg<<=1;
  90.         cs=0;
  91.         reg=reg&0x7e;
  92.         spi(reg);
  93.         spi(da);
  94.         cs=1;
  95. }
  96. /*********************************************************/
  97. //解释：读寄存器函数
  98. //
  99. //
  100. //输入：寄存器地址
  101. //
  102. //
  103. //输出：该寄存器目前的值
  104. //
  105. //注意！！读写寄存器时指令不一样，仔细看。
  106. /********************************************************/
  107. uchar resig_read(uchar reg)
  108. {
  109.         uchar temp;
  110.         sck=0;
  111.         _nop_();
  112.         _nop_();
  113.         cs=0;
  114.         reg<<=1;
  115.         reg|=0x80;
  116.         spi(reg);
  117.         temp=spi(0x00);
  118.         cs=1;
  119.         return temp;
  120.         
  121. }
  122. /*********************************************************/
  123. //解释：FIFO缓衝器的读函数
  124. //
  125. //
  126. //输入：读取的字节个数 ，返回的值存放首地址
  127. //
  128. //
  129. //输出：读成功的话会返回真值，否则返回0
  130. //
  131. //
  132. /********************************************************/
  133. uchar fifo_read(uchar count,uchar *s)
  134. {
  135.         uchar i,temp;
  136.         temp=resig_read(FIFOLength);
  137.         if(temp<count)
  138.         return  0;
  139.         else
  140.         {
  141.                 for(i=0;i<count;i++)
  142.                 {                                       
  143.                         temp=resig_read(FIFODaTa);
  144.                         *(s+i)=temp;
  145.                 }               
  146.         }
  147.         return 1;
  148. }
  149. /*********************************************************/
  150. //解释：FIFO缓衝器的写函数
  151. //
  152. //
  153. //输入：写入的字节个数 ，要写入的值的存放首地址
  154. //
  155. //
  156. //输出：
  157. //
  158. //
  159. /********************************************************/
  160. void fifo_write(uchar count,uchar *s)
  161. {
  162.         uchar i,temp;
  163.         for(i=0;i<count;i++)
  164.         {
  165.                 temp=*(s+i);
  166.                 resig_write(FIFODaTa,temp);
  167.         }
  168. }
  169. /*********************************************************/
  170. //解释：芯片FM1702初始化函数
  171. //
  172. //
  173. //输入：
  174. //
  175. //
  176. //输出：初始化成功的话返回真值，否则返回0
  177. //
  178. //
  179. //注意:初始化步骤非常重要，一定要按照使用手册的启动步骤来，参考所给pdf
  180. /********************************************************/
  181. uchar  inti_1702()
  182. {
  183.         uchar temp,i;
  184.         FM1702rst=1;
  185.         mosi=1;
  186.         sck=1;
  187.     delay(20);                        
  188.         FM1702rst=0;                                 
  189.         delay(20);
  190.         while(resig_read(Command));
  191.         resig_write(0x00,0x80);                              
  192.         temp=resig_read(Command);            
  193.         while(temp);
  194.         resig_write(0x00,0x00);                                           //切换到线性寻址（此命令非常重要，否则无法启动发送 ）
  195.         resig_write(TimerClock,0x0b);                           //address 2AH    /* 定时器週期设置寄存器 */   
  196.         resig_write(TimerControl,0x02);                           //address 2BH        /* 定时器控制寄存器 */   
  197.         resig_write(TimerReload,0x42);                       //address 2CH    /* 定时器初值寄存器 */         
  198.         resig_write(InterruptEn,0x7f);                    //address 06H    /* 中断使能/禁止寄存器 */     
  199.         resig_write(InterruptRq,0x7f);          //address 07H    /* 中断请求标识寄存器 */
  200.         resig_write(MFOUTSelect,0x02);                    //address 26H    /* mf OUT 选择配置寄存器 */     
  201.         resig_write(TxControl,0x5b);                    //address 11H    /* 发送控制寄存器 */
  202.         resig_write(RxControl2,0x01);
  203.         resig_write(RxWait,0x07);
  204.            for(i=0;i<16;i++)
  205.         {
  206.                 Fbuff[i]=0;
  207.                 Jbuff[i]=0;
  208.         }
  209.         lcdclear() ;
  210.         if(temp==0x00)           
  211.         return 1;         
  212.         else
  213.         return 0;         
  214. }
  215. /*********************************************************/
  216. //解释：延时函数，单次延时为5ms
  217. //
  218. //
  219. //输入：要延时的次数
  220. //
  221. //
  222. //输出：
  223. //
  224. //
  225. /********************************************************/
  226. void delay(uchar m)    //单次定时为10ms
  227. {
  228.         TMOD=0x01;
  229.         while(m--)
  230.                 {        
  231.                           TH0=0xfe;
  232.                          TL0=0x33 ;
  233.                         TR0=1;
  234.                         while(!TF0);
  235.                         TF0=0;
  236.                         TR0=0;
  237.                 }
  238.            
  239. }
  240. /*********************************************************/
  241. //解释：卡的回应函数，判断是否有卡在读写器跟前
  242. //
  243. //
  244. //输入：
  245. //
  246. //
  247. //输出：如果有卡在的话返回真值，否则返回0
  248. //
  249. //
  250. /********************************************************/
  251. uchar  request()
  252. {
  253.         uchar  temp;
  254.         resig_write(CRCResultLSB,0x63);
  255.         resig_write(CWConductance,0x3f);
  256.         resig_write(BitFraming,0x07);
  257.         resig_write(ChannelRedundancy,0x03);                  
  258.         temp=resig_read(Control);
  259.         temp=temp&0x7f;
  260.         resig_write(Control,temp);
  261.         resig_read(FIFOLength);
  262.         temp=resig_read(Control);
  263.         temp=temp|0x01;
  264.         resig_write(Control,temp);
  265.         Fbuff[0]=0x52;                           
  266.         fifo_write(1,Fbuff);                                                         
  267.         resig_write(Command,0x1e);               
  268.         delay(1);         
  269.         temp=resig_read(FIFOLength);
  270.         if(temp==0x02)
  271.         return 1;     
  272.         else
  273.         return 0;                           
  274. }
  275. /*********************************************************/
  276. //解释：防衝突函数 （我所做的此函数没有手册的那种功能，只是实现了单卡交易功能）
  277. //
  278. //
  279. //输入：
  280. //
  281. //
  282. //输出：防衝突成功的话返回真值，否则返回0
  283. //
  284. //实现功能：如果有多张卡在读卡器区域，只选中一张，并读取验证这张卡的ID，然后存储
  285. /********************************************************/
  286. uchar card_anticoll()                                                        //防衝突函数
  287. {
  288.         uchar temp,i;
  289.         resig_write(DecoderControl,0x28);                        
  290.         resig_write(Control,0x08);
  291.         resig_write(ChannelRedundancy,0x03);
  292.         temp=resig_read(Control);
  293.         temp=temp|0x01;
  294.         resig_write(Control,temp);                          
  295.         Fbuff[0]=0x93;
  296.         Fbuff[1]=0x20;
  297.         fifo_write(2,Fbuff);
  298.         resig_write(Command,0x1e);
  299.         delay(2);                                                         
  300.         temp=resig_read(FIFOLength);         
  301.         if(temp==0x05)        
  302.         {
  303.                 temp=0;
  304.                 fifo_read(5,UID);
  305.                 delay(1);               
  306.                 for(i=0;i<5;i++)
  307.                 {
  308.                         temp=temp^UID[i];        
  309.                 }
  310.                 if(temp==0)
  311.                 return 1;
  312.                 else
  313.                 return 0;
  314.         }
  315.         else
  316.                  return 0;        
  317. }
  318. /*********************************************************/
  319. //解释：选卡函数
  320. //
  321. //
  322. //输入：
  323. //
  324. //
  325. //输出：选卡成功的话返回真值，否则返回0
  326. //
  327. //实现功能：将要交易的卡号发给卡，如果回应正确则选卡成功
  328. /********************************************************/
  329. uchar   card_select()
  330. {
  331.         uchar i,temp;
  332.         resig_write(ChannelRedundancy,0x0f);
  333.         resig_write(Control,0x08);
  334.         temp=resig_read(Control);
  335.         temp=temp|0x01;
  336.         resig_write(Control,temp);
  337.         Fbuff[0]=0x93;
  338.         Fbuff[1]=0x70;
  339.         for(i=0;i<5;i++)
  340.         {
  341.                 Fbuff[i+2]=UID[i];
  342.         }        
  343.         fifo_write(7,Fbuff);
  344.         resig_write(Command,0x1e);
  345.         delay(2);
  346.         temp=resig_read(FIFOLength);   
  347.         if(temp==0x01)
  348.         return 1          ;
  349.         else
  350.         return 0         ;
  351. }
  352. /*********************************************************/
  353. //解释：三重认证函数
  354. //
  355. //
  356. //输入：要操作的块号
  357. //
  358. //
  359. //输出：如果三重认证的话返回真值，否则返回0
  360. //
  361. //实现功能：这是卡片与读卡器之间的默认通信协议，次程序执行成功后才可以与卡进行交易
  362. /********************************************************/
  363. uchar    card_authtication(uchar m)
  364. {
  365.         uchar i,temp;
  366.         temp=resig_read(Control);
  367.         temp=temp|0x01;
  368.         resig_write(Control,temp);
  369.         Fbuff[0]=0x60;
  370.         Fbuff[1]=m;
  371.         for(i=0;i<4;i++)
  372.         {
  373.                 Fbuff[i+2]=UID[i];
  374.         }
  375.         fifo_write(6,Fbuff);
  376.         resig_write(InterruptEn,0xa5);
  377.         resig_write(Command,0x0c);
  378.         delay(2);
  379.         temp=resig_read(SecondaryStatus);
  380.         temp=temp&0x07;                                                
  381.         if(temp==0)
  382.         {
  383.                 temp=resig_read(Control);
  384.                 temp=temp|0x01;
  385.                 resig_write(Control,temp);
  386.                 resig_write(InterruptEn,0xa4);
  387.                 resig_write(Command,0x14);               
  388.                 delay(2);
  389.                 temp=temp=resig_read(Control);
  390.                 temp&=0x08;
  391.                 if(temp==0x08)
  392.                 return 1;
  393.                 else
  394.                 return 0;               
  395.         }
  396.         return  0;
  397. }
  398. /*********************************************************/
  399. //解释：读卡函数
  400. //
  401. //
  402. //输入：要读的考号
  403. //
  404. //
  405. //输出：读卡成功的话返回真值，否则返回0
  406. //
  407. //实现功能：读取指定卡号的内容，并传送给FIFO
  408. /********************************************************/
  409. uchar card_read(uchar m)
  410. {
  411.         uchar temp;
  412.         temp=resig_read(Control);
  413.         temp=temp|0x01;
  414.         resig_write(Control,temp);
  415.         resig_write(ChannelRedundancy,0x0f);
  416.         temp=resig_read(Control);
  417.         temp=temp|0x01;
  418.         resig_write(Control,temp);
  419.         Fbuff[0]=0x30;
  420.         Fbuff[1]=m;
  421.         fifo_write(2,Fbuff);
  422.         resig_write(Command,0x1e);
  423.         delay(0x04);                                       
  424.         temp=resig_read(FIFOLength);
  425.         if(temp==16)
  426.         {
  427.                
  428.                 fifo_read(16,Jbuff);        
  429.                 return 1;
  430.         }
  431.         else
  432.         return 0;        
  433. }
  434. /*********************************************************/
  435. //解释：写卡函数
  436. //
  437. //
  438. //输入：要写入的卡号
  439. //
  440. //
  441. //输出：写卡成功的话返回真值，否则返回0
  442. //
  443. //实现功能：将发送缓衝区的数据写入指定的块号
  444. /********************************************************/
  445. uchar  card_write(uchar m)
  446. {
  447.         uchar temp;
  448.         temp=resig_read(Control);
  449.         temp=temp|0x01;
  450.         resig_write(Control,temp);
  451.         Fbuff[0]=0xA0;
  452.         Fbuff[1]=m;
  453.         fifo_write(2,Fbuff);
  454.         resig_write(Command,0x1e);
  455.         delay(2);
  456.         temp=resig_read(FIFOLength);
  457.         if(temp==1)
  458.         {
  459.                 temp=resig_read(Control);
  460.                 temp=temp|0x01;
  461.                 resig_write(Control,temp);
  462.                 Fbuff[0]=Jbuff[0];
  463.                 fifo_write(16,Fbuff);
  464.                 resig_write(Command,0x1e);
  465.                 delay(10);        
  466.                 temp=resig_read(FIFOLength);
  467.                 if(temp==1)                        
  468.                 return 1;
  469.                 else
  470.                 return 0;
  471.         }
  472.         else
  473.         return 0;        
  474. }
  475. /*********************************************************/
  476. //解释：加载密匙函数
  477. //
  478. //
  479. //输入：
  480. //
  481. //
  482. //输出：成功的话返回真值，否则返回0
  483. //
  484. //实现功能：建立与卡通信协议的第一步，将密匙发送给卡，验证密匙是否成功，成功的话执行三重认证
  485. /********************************************************/
  486. uchar loadkey()
  487. {
  488.         uchar temp;
  489.         temp=resig_read(Control);
  490.         temp=temp|0x01;
  491.         resig_write(Control,temp);
  492.         fifo_write(12,changekey);
  493.         resig_write(Command,0x19);
  494.         delay(3);
  495.         temp=resig_read(ErrorFlag);
  496.         if(temp==0)
  497.         return 1;
  498.         else
  499.         return 0;
  500. }
  501. /*********************************************************/
  502. //解释：设置卡的暂停态函数
  503. //
  504. //
  505. //输入：
  506. //
  507. //
  508. //输出：执行成功的话返回真值，否则返回0
  509. //
  510. //实现功能：将卡设置为终止交易态，若要再次交易必须从头重新开始认证
  511. /********************************************************/
  512. void  card_halt()
  513. {
  514.         uchar temp;
  515.         resig_write(InterruptEn,0x7f);                        
  516.         resig_write(InterruptRq,0x7f);
  517.         resig_write(Command,0x00);
  518.         temp=resig_read(Control);
  519.         temp=temp|0x01;
  520.         resig_write(Control,temp);
  521.         Fbuff[0]=0x50;
  522.         Fbuff[1]=0x00;
  523.         fifo_write(2,Fbuff);
  524.         resig_write(InterruptEn,0xbd);
  525.         resig_write(Command,0x1e);
  526.         delay(2);
  527. }
  528. /****************按键显示子函数解释********************/
  529. /*********************************************************/
  530. //解释：卡的高两位序列号函数
  531. //
  532. //
  533. //输入：
  534. //
  535. //
  536. //输出：
  537. //
  538. //实现功能：将卡的高两位序列号处理为16进制后存放在相应显示区
  539. /********************************************************/
  540. void  data1deal()     //序列号处理
  541. {
  542.         uchar temp,i;
  543.         for(i=0;i<4;i++)
  544.         Data[i]=0;
  545.         temp=UID[3];
  546.         Data[1]=temp/16;
  547.            Data[0]=temp%16;
  548.         temp=UID[2];
  549.         Data[3]=temp/16;
  550.            Data[2]=temp%16;
  551. }
  552. /*********************************************************/
  553. //解释：显示数据处理函数
  554. //
  555. //
  556. //输入：
  557. //
  558. //
  559. //输出：
  560. //
  561. //实现功能：将要现实的数据处理为10进制后存放在相应显示区
  562. /********************************************************/
  563. void  data2deal(uchar m)     //显示数据及按键处理
  564. {
  565.         uchar i,temp;
  566.         for(i=0;i<4;i++)
  567.         Data[i]=0;
  568.         temp=m;
  569.         Data[0]=temp%10;
  570.         Data[1]=temp%100/10;
  571.         Data[2]=temp/100;        
  572. }
  573. /*********************************************************/
  574. //解释：按键扫描函数
  575. //
  576. //
  577. //输入：
  578. //
  579. //
  580. //输出：输出相应的交易种类以及交易数额（会在说明裡做详细说明）
  581. //
  582. //
  583. /********************************************************/
  584. void keyscan()
  585. {
  586.         if(k2==0||k3==0)
  587.         {
  588.                 if(k2==0)
  589.                 {
  590.                         delay(100);
  591.                         if(k2==0)
  592.                         delay(250);
  593.                         if(keyflag==1)
  594.                         {
  595.                                 if(k2==1)
  596.                                 {
  597.                                         if(count==255)
  598.                                         count=0         ;
  599.                                         else
  600.                                         count++;        
  601.                                 }
  602.                                 if(k2==0)
  603.                                 {
  604.                                         while(!k2)
  605.                                         display();
  606.                                         if(count>=246)
  607.                                         count=count+11;
  608.                                         else
  609.                                         count=count+10;        
  610.                                 }        
  611.                         }
  612.                         else
  613.                         {
  614.                                 chongzhi=1;
  615.                                 shuaka=0;
  616.                         }
  617.                 }
  618.                 if(k3==0)
  619.                 {
  620.                         delay(100);
  621.                         if(k3==0)
  622.                         delay(250);
  623.                         if(keyflag==1)
  624.                         {
  625.                                 if(k3==1)
  626.                                 {
  627.                                         if(count==0)
  628.                                         count=255;
  629.                                         else
  630.                                         count--;        
  631.                                 }
  632.                                 if(k3==0)
  633.                                 {
  634.                                         while(!k3)
  635.                                         display();
  636.                                         if(count<=9)
  637.                                         count=245+count;
  638.                                         else
  639.                                         count=count-10;        
  640.                                 }        
  641.                         }
  642.                         else
  643.                         {
  644.                                 shuaka=1;
  645.                                 chongzhi=0;
  646.                         }
  647.                
  648.                 }        
  649.         }
  650.         if(k4==0)
  651.                 {
  652.                         delay(180);
  653.                         if(k4==0)
  654.                         keyflag=keyflag+1;
  655.                 }
  656. }
  657. /*********************************************************/
  658. //解释：显示函数
  659. //
  660. //
  661. //输入：
  662. //
  663. //
  664. //输出：
  665. //
  666. //
  667. /********************************************************/               
  668. void display()
  669. {        
  670.          unsigned char time=0;
  671.         nWR=0;
  672.         P2=0x0f;
  673.         WR=0;        
  674.         P0=seg[Data[3]];
  675.         WR=1;        
  676.         P2=0X0e;
  677.         time=5000;                        
  678.         while(time--);
  679.          
  680.         nWR=0;
  681.         P2=0x0f;
  682.         WR=0;        
  683.         P0=seg[Data[2]];
  684.         WR=1;        
  685.         P2=0X0d;
  686.         time=5000;                        
  687.         while(time--);         
  688.                   
  689.         nWR=0;
  690.         P2=0x0f;
  691.         WR=0;        
  692.         P0=seg[Data[1]];
  693.         WR=1;        
  694.         P2=0X0b;
  695.         time=5000;                        
  696.         while(time--);
  697.                  
  698.         nWR=0;
  699.         P2=0x0f;
  700.         WR=0;        
  701.         P0=seg[Data[0]];
  702.         WR=1;        
  703.         P2=0X07;
  704.         time=5000;                        
  705.         while(time--);        
  706.         
  707. }
  708. /*********************************************************/
  709. //解释：lcd清屏函数
  710. //
  711. //
  712. //输入：
  713. //
  714. //
  715. //输出：
  716. //
  717. /********************************************************/
  718. void lcdclear()
  719. {
  720.          nWR=0;
  721.         P2=0x0f;
  722.         WR=0;        
  723.         P0=0xff;
  724.         WR=1;        
  725.         P2=0X0e;
  726.          
  727.         nWR=0;
  728.         P2=0x0f;
  729.         WR=0;        
  730.         P0=0xff;
  731.         WR=1;        
  732.         P2=0X0d;

  734.         nWR=0;
  735.         P2=0x0f;
  736.         WR=0;        
  737.         P0=0xff;
  738.         WR=1;        
  739.         P2=0X0b;
  740.                  
  741.         nWR=0;
  742.         P2=0x0f;
  743.         WR=0;        
  744.         P0=0xff;
  745.         WR=1;        
  746.         P2=0X07;

  748. }
  749. /*****************************主函数****************************/
  750. void  main()
  751. {
  752.         uchar temp,p,i,j;

  754.         temp=inti_1702();        
  755.         while(1)
  756.         {
  757.                 switch(temp)
  758.                 {
  759.                         case 0:        p=inti_1702();if(p) temp++;else temp=0;break;
  760.                         case 1: p=request(); if(p) {temp++;led5=~led5;}else temp=1;break;
  761.                         case 2: p=card_anticoll(); if(p){ temp++;led6=~led6;}else temp=1;break;
  762.                         case 3:        p=card_select(); if(p)  temp++; else temp=1;break;
  763.                         case 4:        p=loadkey();if(p){temp++;led7=~led7;} else temp=1;break;
  764.                         case 5:        p=card_authtication(PICC_BLOCK);if(p){ temp++;led8=~led8;}else temp=1;break;
  765.                         case 6: p=card_read(PICC_BLOCK);
  766.                         if(p)
  767.                         {
  768.                                 temp++;
  769.                                 data1deal();
  770.                                 for(i=0;i<2;i++)
  771.                                 for(j=0;j<150;j++)
  772.                                 display();
  773.                                 data2deal(Jbuff[0]);
  774.                                 i=10;
  775.                                 j=200;
  776.                                 while(i--)
  777.                                 {        
  778.                                         while(j--)
  779.                                         {        display();
  780.                                                 keyscan();
  781.                                                 if(shuaka||chongzhi)
  782.                                                 {        data2deal(count);
  783.                                                         display();
  784.                                                         if(keyflag==0x02)
  785.                                                         {
  786.                                                                 if(shuaka)
  787.                                                                 Jbuff[0]=Jbuff[0]-count        ;
  788.                                                                 if(chongzhi)
  789.                                                                 Jbuff[0]=Jbuff[0]+count;
  790.                                                                 keyflag=0;
  791.                                                                 shuaka=0;
  792.                                                                 chongzhi=0;
  793.                                                                 count=0;        
  794.                                                                 j=0;
  795.                                                                 i=0;
  796.                                                         }
  797.                                                           else
  798.                                                         j=100;
  799.                                                 }
  800.                                        
  801.                                         }
  802.                                 }
  803.                                 
  804.                         }
  805.                         else
  806.                         temp=0;break;
  807.                         case 7:        p=card_write(PICC_BLOCK);if(p){temp++;led9=~led9;} else temp=0;break;
  808.                         case 8:        p=card_read(PICC_BLOCK);
  809.                         if(p)
  810.                         {
  811.                                 temp++;
  812.                                 data1deal();
  813.                                 for(i=0;i<2;i++)
  814.                                 for(j=0;j<150;j++)
  815.                                 display();
  816.                                 data2deal(Jbuff[0]);
  817.                                 i=5;
  818.                                 j=200;
  819.                                 while(i--)
  820.                                 {        
  821.                                         while(j--)
  822.                                         display();
  823.                                 }
  824.                                 lcdclear() ;
  825.                         }
  826.                         else
  827.                         temp=0; break;
  828.                         case 9: card_halt();temp=0;break;
  829.                         default: break;
  830.                
  831.                 }
  832.         }
  833. }
复制代码

所有资料51hei提供下载:
基於51的FM1702射頻卡.rar (3.26 MB, 下载次数: 94)
回复

使用道具 举报

ID:1 发表于 2018-11-6 02:25 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:593106 发表于 2020-5-12 17:14 | 显示全部楼层
感谢楼主分享，学习学习，参考参考
回复

使用道具 举报

ID:313854 发表于 2024-5-14 11:53 | 显示全部楼层
太感谢了，代码好详细
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表