找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 5540|回復(fù): 6
收起左側(cè)

51單片機(jī)硬幣識別系統(tǒng)設(shè)計(jì)（文檔+電路+程序）

[復(fù)制鏈接]
ID:568925 發(fā)表于 2019-6-23 13:28 | 顯示全部樓層 |閱讀模式
本設(shè)計(jì)基于51內(nèi)核的單片機(jī)的高識別率硬幣識別裝置，主要應(yīng)用于各公共營業(yè)場所，如各超市，自動售貨機(jī)，公共交通等。它應(yīng)該能完成一角（分新版舊版），五角，一元硬幣的識別，并高效率篩選假幣，游戲幣并將識別情況實(shí)時(shí)顯示等功能，同時(shí)具有精度高、功耗低、抗干擾能力強(qiáng)等特點(diǎn)。  

本文主要從硬件和軟件兩部分來設(shè)計(jì)整個(gè)系統(tǒng)和功能的實(shí)現(xiàn)。硬件方面：為滿足對硬幣高識別率的要求，采用8位單片機(jī)、電磁傳感器、激光傳感器、LCD12864。系統(tǒng)的核心是基于51內(nèi)核單片機(jī)，以模塊化的設(shè)計(jì)方法將裝置的硬件按功能分為幾大模塊進(jìn)行設(shè)計(jì)，分別為：電源模塊、電磁傳感器模塊、激光傳感器模塊、顯示模塊、濾波放大模塊、A/D轉(zhuǎn)換、控制模塊。電源模塊為系統(tǒng)提供電源，電磁傳感器形成渦流效應(yīng)，實(shí)現(xiàn)對真假硬幣的鑒別，激光傳感器檢測硬幣的有無和硬幣大小的直徑信息，利用芯片內(nèi)部A/D轉(zhuǎn)換電路把模擬量轉(zhuǎn)換成數(shù)字量，控制模塊是利用舵機(jī)來控制對硬幣的篩選，顯示模塊是將硬幣真?zhèn)魏徒灰走^程和找零結(jié)果顯示出來。

捕獲.PNG

1.PNG
2.PNG
3.PNG

單片機(jī)源程序如下:
  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時(shí)為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時(shí)為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. //}
復(fù)制代碼

全部資料51hei下載地址：
硬幣識別.zip (3.75 MB, 下載次數(shù): 114)

回復(fù)

使用道具 舉報(bào)

ID:398752 發(fā)表于 2019-7-28 21:03 | 顯示全部樓層
樓主，你的電磁傳感器是什么型號
回復(fù)

使用道具 舉報(bào)

ID:414556 發(fā)表于 2019-11-10 14:02 | 顯示全部樓層
樓主威武啊,是以電壓的高低判斷幣的類型嗎
回復(fù)

使用道具 舉報(bào)

ID:553945 發(fā)表于 2020-6-28 23:29 來自手機(jī) | 顯示全部樓層
同問，傳感器用的什么型號
回復(fù)

使用道具 舉報(bào)

ID:416239 發(fā)表于 2020-6-29 07:17 | 顯示全部樓層
是以什么方法去判斷錢呢？
回復(fù)

使用道具 舉報(bào)

ID:1082059 發(fā)表于 2023-6-11 17:55 來自手機(jī) | 顯示全部樓層
要是有人能根據(jù)樓主的程序做個(gè)仿真圖就好了
回復(fù)

使用道具 舉報(bào)

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

手機(jī)版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機(jī)教程網(wǎng)

快速回復(fù) 返回頂部 返回列表