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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机硬币识别系统设计（文档+电路+程序）
返回列表 发新帖
查看: 4433|回复: 6
打印 上一主题 下一主题
收起左侧

51单片机硬币识别系统设计（文档+电路+程序）

[复制链接]
跳转到指定楼层
楼主
ID:568925 发表于 2019-6-23 13:28 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
本设计基于51内核的单片机的高识别率硬币识别装置，主要应用于各公共营业场所，如各超市，自动售货机，公共交通等。它应该能完成一角（分新版旧版），五角，一元硬币的识别，并高效率筛选假币，游戏币并将识别情况实时显示等功能，同时具有精度高、功耗低、抗干扰能力强等特点。  

本文主要从硬件和软件两部分来设计整个系统和功能的实现。硬件方面：为满足对硬币高识别率的要求，采用8位单片机、电磁传感器、激光传感器、LCD12864。系统的核心是基于51内核单片机，以模块化的设计方法将装置的硬件按功能分为几大模块进行设计，分别为：电源模块、电磁传感器模块、激光传感器模块、显示模块、滤波放大模块、A/D转换、控制模块。电源模块为系统提供电源，电磁传感器形成涡流效应，实现对真假硬币的鉴别，激光传感器检测硬币的有无和硬币大小的直径信息，利用芯片内部A/D转换电路把模拟量转换成数字量，控制模块是利用舵机来控制对硬币的筛选，显示模块是将硬币真伪和交易过程和找零结果显示出来。







单片机源程序如下:
  1. #include <stc12c5410ad.h>
  2. #define uchar unsigned        char
  3. #define uint unsigned int

  5. sbit pwm1=P3^2;
  6. sbit pwm2=P3^3;
  7. sbit pwm3=P3^4;

  9. sbit lcden=P1^3;
  10. sbit lcdrs=P1^4;
  11. sbit key2=P1^0;
  12. sbit key1=P1^2;
  13. sbit key3=P1^5;
  14. sbit key4=P1^6;
  15. sbit key5=P1^7;

  17. uint set1,set2,set3,angle1,angle2,angle3,value,
  18. time1,a,b,date,coin_count=-1,coin_error,ttff=1,
  19. coin_add,coin_set,key,temp,noww,ab,kkey1,kkey2,kkey3,kkey4,
  20. c,d,e,f,g,h,i,j,kkk;
  21. float dat;

  23. uchar code sett[]="set:";
  24. uchar code add[]="add:";
  25. uchar code y[]=".Y";
  26. uchar code now[]={"N:"};
  27. uchar code TF[]={"TF"};
  28. uchar code coin[]={"0123456789"};
  29. uchar code success[]={"success"};
  30. uchar code error[]={"+-"};
  31. uchar code pay[]={"paymentsuccess"};
  32. uchar code pladd[]={"pleaseadd"};
  33. uchar code pltake[]={"pleasetake"};
  34. uchar code welcome[]={"xinxi1138ZhengXin"};

  36. uint coins[4];

  38. void matrixkeyscan();

  40. void delay(uint i)
  41. {                                       
  42.            uint x,y;
  43.          for(x=i;x>0;x--)        
  44.                  for(y=110;y>0;y--);
  45. }

  47. void write_com(uchar com)
  48. {
  49.         lcdrs=0;
  50.          P2=com;
  51.         delay(5);
  52.         lcden=1;
  53.         delay(5);
  54.         lcden=0;
  55. }
  56. void write_data(uchar date)
  57. {
  58.         lcdrs=1;
  59.         P2=date;
  60.         delay(5);
  61.         lcden=1;
  62.         delay(5);
  63.         lcden=0;
  64. }

  66. void init_1602()
  67. {
  68.         lcden=0;
  69.         write_com(0x38);
  70.         write_com(0x0c);
  71.         write_com(0x06);
  72.         write_com(0x01);
  73. }


  76. void init_ad()
  77. {
  78.   ADC_CONTR|=0x89;
  79.   delay(5);
  80.   P1M0=0x02;
  81.   P1M1=0x02;
  82.   ADC_DATA=0;
  83.   ADC_CONTR|=0Xe1;
  84. }

  86. void qu_ad()
  87. {
  88.         ADC_CONTR|=0X08;
  89.     delay(1);
  90.     while(ADC_CONTR&0x10==0);
  91.     {
  92.         ADC_CONTR&=0Xe9;
  93.         }
  94.         dat=ADC_DATA;
  95.     dat=(5*dat)/256;        
  96.         delay(5);
  97.         dat+=0.05;
  98.         dat*=10;
  99.         date=dat;
  100.         value=date;
  101.         a=date/10;
  102.         b=date%10;         
  103. }

  105. void welcome_led()
  106. {

  108.   uchar i;

  110. write_com(0x80+2);
  111. for(i=0;i<7;i++)
  112. {
  113. write_data(welcome[i]);
  114. delay(2);
  115. }

  117. write_com(0x80+10);
  118. for(i=7;i<9;i++)
  119. {
  120. write_data(welcome[i]);
  121. delay(2);
  122. }

  124. write_com(0x80+0x40+3);
  125. for(i=9;i<14;i++)
  126. {
  127. write_data(welcome[i]);
  128. delay(2);
  129. }

  131. write_com(0x80+0x40+9);
  132. for(i=14;i<17;i++)
  133. {
  134. write_data(welcome[i]);
  135. delay(2);
  136. }

  138. delay(15000);
  139. write_com(0x01);
  140. }

  142. void lcd_1602()
  143. {
  144.         
  145.         uint k;

  147.         write_com(0x80);
  148.     for(k=0;k<=3;k++)
  149.         {
  150.         write_data(sett[k]);
  151.         delay(2);
  152.         }

  154.         write_com(0x80+0x40+0);
  155.         for(k=0;k<=3;k++)
  156.         {
  157.         write_data(add[k]);
  158.         delay(2);
  159.         }

  161.         write_com(0x80+5);
  162.         write_data(y[0]);
  163.         delay(2);
  164.         write_com(0x80+7);
  165.         write_data(y[1]);
  166.         delay(2);

  168.         write_com(0x80+0x40+5);
  169.         write_data(y[0]);
  170.         delay(2);
  171.         write_com(0x80+0x40+7);
  172.         write_data(y[1]);
  173.         delay(2);

  175.         write_com(0x80+0x40+9);
  176.         for(k=0;k<=1;k++)
  177.         {
  178.         write_data(now[k]);
  179.         delay(2);
  180.         }

  182.         write_com(0x80+0x40+12);
  183.         write_data(y[0]);
  184.         delay(2);

  186.         write_com(0x80+0x40+14);
  187.         write_data(y[1]);

  189.         write_com(0x80+4);
  190.         write_data(coin[c]);
  191.         write_com(0x80+6);
  192.         write_data(coin[d]);

  194.         c=coin_set/10;
  195.          d=coin_set%10;

  197.         write_com(0x80+0x40+4);
  198.         write_data(coin[e]);
  199.         write_com(0x80+0x40+6);
  200.         write_data(coin[f]);

  202.         e=coin_add/10;
  203.         f=coin_add%10;        

  205.         write_com(0x80+0x40+11);
  206.         write_data(coin[g]);
  207.         delay(2);
  208.         write_com(0x80+0x40+13);
  209.         write_data(coin[h]);

  211.         g=noww/10;
  212.         h=noww%10;

  214.         write_com(0x80+12);
  215.         write_data(TF[ttff]);
  216.         delay(2);


  219.         if(kkey2%2==1)
  220.         {
  221.         if((coin_set==coin_add) && (coin_set!=0))
  222.         {
  223.          write_com(0x01);
  224.          for(;;)
  225.          {
  226.           write_com(0x80+1);
  227.           for(k=0;k<=6;k++)
  228.           {
  229.           write_data(pay[k]);
  230.           delay(2);
  231.           }        
  232.          
  233.           write_com(0x80+9);
  234.           for(k=7;k<=13;k++)
  235.           {
  236.           write_data(pay[k]);
  237.           delay(2);
  238.           }        
  239.          
  240.            if(key2==0)
  241.                  {
  242.                  while(!key2);
  243.                  kkey2++;
  244.                  }

  246.           if(kkey2%2==0)
  247.           {
  248.           write_com(0x01);
  249.           delay(50);
  250.           break;
  251.          
  252.           }
  253.                               
  254.          };
  255.     }
  256.         
  257.         if((coin_set>coin_add) && (coin_set!=0))
  258.         {
  259.          write_com(0x01);
  260.          for(;;)
  261.          {
  262.           write_com(0x80+2);
  263.           for(k=0;k<=5;k++)
  264.           {
  265.           write_data(pladd[k]);
  266.           delay(2);
  267.           }        
  268.          
  269.           write_com(0x80+10);
  270.           for(k=6;k<=8;k++)
  271.           {
  272.           write_data(pladd[k]);
  273.           delay(2);
  274.           }                 
  275.         
  276.           coin_error=coin_set-coin_add;
  277.                           
  278.           i=coin_error/10;
  279.           j=coin_error%10;
  280.           write_com(0x80+0x40+6);
  281.           write_data(coin[i]);
  282.           write_com(0x80+0x40+7);
  283.           write_data(y[0]);
  284.           write_com(0x80+0x40+8);
  285.           write_data(coin[j]);
  286.           write_com(0x80+0x40+9);
  287.           write_data(y[1]);

  289.            if(key2==0)
  290.                  {
  291.                  while(!key2);
  292.                  kkey2++;
  293.                  }

  295.           if(kkey2%2==0)
  296.           {
  297.           write_com(0x01);
  298.           delay(50);
  299.           break;
  300.           }

  302.          };
  303.     }

  305.         if((coin_set<coin_add) && (coin_set!=0))
  306.         {
  307.          write_com(0x01);
  308.          for(;;)
  309.          {
  310.           write_com(0x80+2);
  311.           for(k=0;k<=5;k++)
  312.           {
  313.           write_data(pltake[k]);
  314.           delay(2);
  315.           }        
  316.          
  317.           write_com(0x80+10);
  318.           for(k=6;k<=9;k++)
  319.           {
  320.           write_data(pltake[k]);
  321.           delay(2);
  322.           }        
  323.          
  324.           coin_error=coin_add-coin_set;

  326.           i=coin_error/10;
  327.           j=coin_error%10;
  328.           write_com(0x80+0x40+6);
  329.           write_data(coin[i]);
  330.           write_com(0x80+0x40+7);
  331.           write_data(y[0]);
  332.           write_com(0x80+0x40+8);
  333.           write_data(coin[j]);
  334.           write_com(0x80+0x40+9);
  335.           write_data(y[1]);

  337.                 if(coin_error!=0)
  338.                 {
  339.                   angle3=25;
  340.                   delay(2000);
  341.               if(angle3>25)
  342.                   {
  343.                   angle3-=8;
  344.                   delay(8000);
  345. //          coin_set+=1;
  346.                   }
  347.                   if(angle3<33)
  348.                   {
  349.                   angle3+=8;
  350.           delay(8000);
  351.           coin_set+=1;
  352.                   }         
  353.                 }

  355.                 if(coin_error==0)
  356.                 {
  357.                 angle3=0;
  358.                 write_com(0x01);
  359.                 delay(50);
  360.                 for(;;)
  361.                 {
  362.                  write_com(0x80+1);
  363.              for(k=0;k<=6;k++)
  364.              {
  365.                    write_data(pay[k]);
  366.                    delay(2);
  367.                    }        
  368.          
  369.                    write_com(0x80+9);
  370.                    for(k=7;k<=13;k++)
  371.                  {
  372.                   write_data(pay[k]);
  373.                  delay(2);
  374.              }        

  376.                  if(key2==0)
  377.                   {
  378.                   while(!key2);
  379.                   kkey2++;
  380.                   }
  381.                
  382.                 if(kkey2%2==0)
  383.             {
  384.             write_com(0x01);
  385.             kkk=1;
  386.             delay(50);
  387.             break;
  388.             }


  391.                 };



  395.          
  396.                 }

  398.             if(key2==0)
  399.                  {
  400.                  while(!key2);
  401.                  kkey2++;
  402.                  }

  404.           if(kkey2%2==0)
  405.           {
  406.           coin_add=0;
  407.           coin_set=0;
  408.           kkey1=0;
  409.           delay(50);
  410.           break;  
  411.           }
  412.                      

  414.          };
  415.     }



  419.         }


  422.         
  423.         if((value==45|| value==44|| value==43)&& (ab==1|| ab==5|| ab==10) )
  424.         {
  425.          delay(2000);
  426.          if((value==45|| value==44|| value==43)&& (ab==1|| ab==5|| ab==10) )
  427.          {
  428.          ttff=1;
  429.          coin_add+=noww;        
  430.          noww=0;
  431.          ab=20;
  432.         }
  433.         }


  436.         if(value==34||value==33||value==32||value==41||value==40
  437.         ||value==39|| value==38|| value==37||value==28 ||
  438.          value==27|| value==26)

  440.         {
  441.         delay(3000);


  444.         if(value==34||value==33||value==32&&(ab==20))
  445.         {
  446.            delay(1000);
  447.          if(value==34||value==33||value==32&&(ab==20))
  448.          {
  449.          noww=5;
  450.          ab=5;

  452.          ttff=0;
  453.          write_com(0x80+12);
  454.          write_data(TF[ttff]);
  455.          delay(2);

  457.          g=noww/10;
  458.          h=noww%10;

  460.          write_com(0x80+0x40+11);
  461.          write_data(coin[g]);
  462.          delay(2);
  463.          write_com(0x80+0x40+13);
  464.          write_data(coin[h]);

  466.          angle2=50;
  467.          delay(3000);
  468.          angle2=0;
  469.          angle1=34;
  470.          delay(3000);
  471.          angle1=27;
  472.          delay(2000);
  473.          angle1=0;
  474.          
  475.          
  476.          
  477.          }
  478.         }

  480.         if(value==41||value==40&&(ab==20))
  481.         {
  482.          delay(1000);
  483.          if(value==41||value==40&&(ab==20))
  484.          {
  485.          noww=1;
  486.          ab=1;

  488.          ttff=0;
  489.          write_com(0x80+12);
  490.          write_data(TF[ttff]);
  491.          delay(2);

  493.          g=noww/10;
  494.          h=noww%10;

  496.          write_com(0x80+0x40+11);
  497.          write_data(coin[g]);
  498.          delay(2);
  499.          write_com(0x80+0x40+13);
  500.          write_data(coin[h]);

  502.          angle2=45;
  503.          delay(3000);
  504.          angle2=0;
  505.          angle1=34;
  506.          delay(3000);
  507.          angle1=27;
  508.          delay(2000);
  509.          angle1=0;
  510.         
  511.          
  512.          }
  513.         }

  515.         if(value==39|| value==38|| value==37&&(ab==20))
  516.         {
  517.          delay(1000);
  518.          if(value==39|| value==38|| value==37&&(ab==20))
  519.          {
  520.          noww=1;
  521.          ab=1;

  523.          ttff=0;
  524.          write_com(0x80+12);
  525.          write_data(TF[ttff]);
  526.          delay(2);

  528.          g=noww/10;
  529.          h=noww%10;

  531.          write_com(0x80+0x40+11);
  532.          write_data(coin[g]);
  533.          delay(2);
  534.          write_com(0x80+0x40+13);
  535.          write_data(coin[h]);

  537.          angle2=45;
  538.          delay(3000);
  539.          angle2=0;
  540.          angle1=34;
  541.          delay(3000);
  542.          angle1=27;
  543.          delay(2000);
  544.          angle1=0;
  545.         
  546.          }
  547.         }

  549.         if(value==28 || value==27 || value==26 &&(ab==20))
  550.         {
  551.         delay(1000);
  552.          if(value==28 || value==27 || value==26 &&(ab==20))
  553.          {
  554.          noww=10;
  555.          ab=10;

  557.          ttff=0;
  558.          write_com(0x80+12);
  559.          write_data(TF[ttff]);
  560.          delay(2);

  562.          g=noww/10;
  563.          h=noww%10;

  565.          write_com(0x80+0x40+11);
  566.          write_data(coin[g]);
  567.          delay(2);
  568.          write_com(0x80+0x40+13);
  569.          write_data(coin[h]);

  571.          angle2=55;
  572.          delay(3000);
  573.          angle2=0;
  574.          angle1=34;
  575.          delay(3000);
  576.          angle1=27;
  577.          delay(2000);
  578.          angle1=0;
  579.         
  580.          }
  581.         }
  582.   }
  583. //write_com(0x80+14);
  584. //write_data(coin[a]);
  585. //delay(2);                                         // 测试
  586. //write_com(0x80+15);
  587. //write_data(coin[b]);
  588. //delay(2);
  589. }

  591. void matrixkeyscan() {

  593. if(key1==0)
  594. {
  595. while(!key1);
  596. coin_set+=1;

  598. if(kkey1==100)
  599. {
  600. kkey1=0;
  601. }
  602. }

  604. if(key2==0 && coin_set!=0)
  605. {
  606. while(!key2);
  607. kkey2++;
  608. if(kkey2==100)
  609. {
  610. kkey2=0;
  611. }
  612. }

  614. if(key3==0)
  615. {
  616. while(!key3);
  617. coin_set+=5;
  618. }

  620. if(key4==0)
  621. {
  622. while(!key4);
  623. coin_set+=10;
  624. }

  626. if(key5==0)
  627. {
  628. while(!key5);
  629. coin_set=0;
  630. }


  633. }


  636. void init_timer()
  637. {
  638. TMOD=0X02;
  639. TH0=(65536-58)/256;                 //15时为20KHZ，50%占空比的方波
  640. TL0=(65536-58)%256;
  641. //TH1=(65536-50000)/256;
  642. //TL1=(65536-50000)%256;
  643. EA=1;
  644. ET0=1;
  645. TR0=1;
  646. //ET1=1;
  647. //TR1=1;
  648. }

  650. void main()
  651. {
  652. init_timer();
  653. init_ad();
  654. init_1602();
  655. pwm1=0;
  656. pwm2=0;
  657. pwm3=0;
  658. angle1=0;   //27-zhong         34-you
  659. angle2=0;                //60-you1        55-you2         50-you3   45-you4
  660. angle3=0;         //25-zuo         33-you

  662. welcome_led();

  664. while(1)
  665. {
  666. qu_ad();
  667. lcd_1602();
  668. matrixkeyscan();
  669. }

  671. }

  673. void  timer_0 () interrupt 1
  674. {

  676. TH0=(65536-58)/256;                 //15时为20KHZ，50%占空比的方波
  677. TL0=(65536-58)%256;

  679. if(set1<angle1)
  680. pwm1=1;
  681. else
  682. pwm1=0;
  683. set1++;

  685. if(set2<angle2)
  686. pwm2=1;
  687. else
  688. pwm2=0;
  689. set2++;

  691. if(set3<angle3)
  692. pwm3=1;
  693. else
  694. pwm3=0;
  695. set3++;

  697. if(set1>546) set1=0;    //145
  698. if(set2>546) set2=0;    //145
  699. if(set3>546) set3=0;    //145
  700. }

  702. //void  timer_1 () interrupt 3
  703. //{
  704. //
  705. // TH0=(65536-50000)/256;                 
  706. // TL0=(65536-50000)%256;
  707. // time1++;
  708. //
  709. // if(time1==20)
  710. // {
  711. //
  712. // time1=0;
  713. // }
  714. //
  715. //  
  716. //}
复制代码

全部资料51hei下载地址：
硬币识别.zip (3.75 MB, 下载次数: 112)

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:398752 发表于 2019-7-28 21:03 | 只看该作者
楼主，你的电磁传感器是什么型号
回复

使用道具 举报

板凳
ID:414556 发表于 2019-11-10 14:02 | 只看该作者
楼主威武啊,是以电压的高低判断币的类型吗
回复

使用道具 举报

地板
ID:553945 发表于 2020-6-28 23:29 来自手机 | 只看该作者
同问，传感器用的什么型号
回复

使用道具 举报

5#
ID:416239 发表于 2020-6-29 07:17 | 只看该作者
是以什么方法去判断钱呢？
回复

使用道具 举报

6#
ID:1082059 发表于 2023-6-11 17:55 来自手机 | 只看该作者
要是有人能根据楼主的程序做个仿真图就好了
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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