devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

带语音播报的51单片机电子体重秤设计(源码+原理图+资料)_51单片机体重秤的代码

作者：知新_RL | 2024-06-12 06:55:10

赞

踩

51单片机体重秤的代码

1、概要

1、实现0~150KG的量程称量；
2、实时显示称量结果在1602上；
3、最小误差为0.01KG；
4、称量体重或物体时待结果稳定后，实现语音播报结果；
5、语音播报可手动关闭或打开；
6、由于传感器一致性差异，体重计算的系数可手动调节。

2、所用到的物料

1、STC89C52单片机
2、1602液晶
3、JQ8900-16P语音模块
4、HX711称重模块
5、洞洞板、下载线、晶振、电容、电阻、按键、排针等

3、实物照片

4、原理图

5、模块使用说明

        JQ8900-16P 选用的是 SOC 方案，集成了一个 16 位的 MCU，以及一个专门针对音频解码的ADSP，采用硬解码的方式，更加保证了系统的稳定性和音质。小巧尺寸更加满足嵌入其它产品的需求。
        SPI-flash 更换语音内容
        此芯片最大的优势在于能够灵活的更换 SPI-flash 内的语音内容，省去了传统语音芯片需要安装上位机更换语音的麻烦，SPI FLASH 直接模拟成 U 盘，跟拷贝 U 盘一样，非常方便。使得产品研发和生产变得便捷简单。一线串口控制模式、RX232 串口控制可选，为研发提供更多的选择性。 USB 数据线连接芯片，插上电脑，电脑会自动识别。

6、程序

完整代码点击顶部链接下载

  1. #include <reg52.H>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. #define PX_1602 P1
  5.  
  6. sbit RS =P3^2;               
  7. sbit RW =P3^3;
  8. sbit E  =P3^4;
  9.  
  10. /*sbit RS =P1^3;               
  11. sbit RW =P1^4;
  12. sbit E  =P1^5;*/
  13.  
  14. sbit kset =P2^0;
  15. sbit kup  =P2^2;
  16. sbit kdown=P2^1;
  17.  
  18. sbit ADDO = P2^4;
  19. sbit ADSK = P2^3;
  20.  
  21. sbit sda =P3^5;
  22. sbit busy=P3^6;
  23.  
  24. uchar code str1[]={"Test weight:         "};
  25. uchar code str2[]={"   00.0Kg  Voice"};
  26. uchar code str11[]={"Welcome to use"};
  27. uchar code str22[]={"Password:"};
  28. uchar code set1[]={"Voice"};
  29. uchar code set2[10]={"      "};
  30. unsigned long buf=0,maopi=0,shiwu=0,shiwu2=0,shiwu_buf=0,gu=84866;
  31. uchar  key,TSS,flag=0;
  32. uint t;
  33. int set_num,xishu=38;
  34. double kg;
  35.  
  36. void ddelay(uint cnt)
  37. {
  38.         while(cnt--);
  39. }
  40.  
  41. void delay(uint z)
  42. {
  43.         uint x,y;
  44.         for(x=z;x>0;x--)
  45.            for(y=110;y>0;y--);        
  46. }
  47.  
  48. void Delay1us (uint T )
  49. {
  50.     while ( T-- );
  51. }
  52.  
  53. void SendData (uchar addr)
  54. {
  55.     uchar i;
  56.  
  57.     EA = 0;
  58.  
  59.     sda = 1;
  60.     Delay1us ( 1000 );
  61.     sda = 0;
  62.     Delay1us ( 420 );
  63.  
  64.     for ( i = 0; i < 8; i++ )
  65.     {
  66.         sda = 1;
  67.         if ( addr & 0x01 )
  68.         {
  69.             Delay1us ( 300 );
  70.             sda = 0;
  71.             Delay1us ( 100 );
  72.         }
  73.         else      
  74.         {
  75.             Delay1us ( 100 );
  76.             sda = 0;
  77.             Delay1us ( 300 );
  78.         }
  79.         addr >>= 1;
  80.     }
  81.     sda = 1;
  82.     EA = 1;//????
  83. }
  84.                
  85. void WriteCMD(uchar command)               
  86. {
  87.         RS = 0;
  88.         RW = 0;
  89.         ddelay(20);
  90.         E = 1;
  91.         ddelay(20);
  92.         PX_1602 = command;
  93.         ddelay(30);
  94.         E = 0;
  95.         ddelay(50);
  96. }
  97.  
  98. void WriteDAT(uchar dat)               
  99. {
  100.         RS = 1;
  101.         RW = 0;
  102.         ddelay(20);
  103.         E = 1;
  104.         ddelay(20);
  105.         PX_1602 = dat;
  106.         ddelay(30);
  107.         E = 0;
  108.         ddelay(50);
  109. }
  110.  
  111. void init_1602()                  
  112. {
  113.         uchar num;
  114.         E=0;
  115.         WriteCMD(0x38);
  116.         WriteCMD(0x38);         
  117.         WriteCMD(0x0c);        
  118.         WriteCMD(0x06);      
  119.         WriteCMD(0x01);        
  120.         WriteCMD(0x80);      
  121.  
  122.   for(num=0;num<16;num++)
  123.         {
  124.                 WriteDAT(str1[num]);
  125.                 //if(num==4){WriteCMD(0x80+4);WriteDAT(0xd0+15);}        
  126.                 delay(20);
  127.   }
  128.         
  129.         WriteCMD(0x80+0x40);
  130.         for(num=0;num<16;num++)
  131.         {
  132.                 WriteDAT(str2[num]);
  133.                 delay(20);
  134.           }
  135.         delay(200);                                  //yan shi 100us(12Mjingzheng)
  136. }
  137.  
  138. void password()
  139. {
  140.         uchar num,kk=1;
  141.         uchar ps1,ps2,ps3,ps4,ps5,ps6,ps7;
  142.         E=1;
  143.         WriteCMD(0x38);
  144.         WriteCMD(0x38);         
  145.         WriteCMD(0x0c);        
  146.         WriteCMD(0x06);      
  147.         WriteCMD(0x01);        
  148.         WriteCMD(0x80);
  149.  
  150.   for(num=0;num<14;num++)
  151.         {
  152.                 WriteDAT(str11[num]);
  153.                 delay(20);
  154.   }        
  155.         WriteCMD(0x80+0x40);
  156.         for(num=0;num<9;num++)
  157.         {
  158.                 WriteDAT(str22[num]);
  159.                 delay(20);
  160.           }
  161.         delay(200);                                  //yan shi 100us(12Mjingzheng)
  162.         WriteCMD(0x80+0x49);
  163.         WriteCMD(0x0f);
  164.         while(1)
  165.         {
  166.                 if(kset==0)
  167.                 {
  168.                         delay(10);
  169.                         if(kset==0)
  170.                         {
  171.                                 kk++;
  172.                                 while(kset==0);
  173.                                 WriteCMD(0x0f);
  174.                                 switch (kk)
  175.                                 {
  176.                                         case 1 : WriteCMD(0x80+0x49); break;
  177.                                         case 2 : WriteCMD(0x80+0x4a); break;
  178.                                         case 3 : WriteCMD(0x80+0x4b); break;
  179.                                         case 4 : WriteCMD(0x80+0x4c); break;
  180.                                         case 5 : WriteCMD(0x80+0x4d); break;
  181.                                         case 6 : WriteCMD(0x80+0x4e); break;
  182.                                         case 7 : WriteCMD(0x80+0x4f); break;
  183.                                         case 8 : kk=1;WriteCMD(0x80+0x49); break;
  184.                                 }
  185.                         }
  186.                 }
  187.                 if(kk==1)
  188.                 {
  189.                         if(ps1==2&&ps2==0&&ps3==1&&ps4==8&&ps5==6&&ps6==6&&ps7==6)break;
  190.                         if(kup==0)
  191.                         {
  192.                                 delay(100);
  193.                                 if(kup==0)
  194.                                 {
  195.                                         if(kdown==0)break;
  196.                                         ps1++;if(ps1>=10)ps1=0;
  197.                                         WriteCMD(0x80+0x49);
  198.                                         WriteDAT(0x30+ps1);
  199.                                         WriteCMD(0x80+0x49);
  200.                                         WriteCMD(0x0e);
  201.                                 }
  202.                         }
  203.                         if(kdown==0)
  204.                         {
  205.                                 delay(100);
  206.                                 if(kdown==0)
  207.                                 {
  208.                                         if(kup==0)break;
  209.                                         if(ps1>0)ps1--;
  210.                                         else ps1=9;
  211.                                         WriteCMD(0x80+0x49);
  212.                                         WriteDAT(0x30+ps1);
  213.                                         WriteCMD(0x80+0x49);
  214.                                         WriteCMD(0x0e);
  215.                                 }
  216.                         }
  217.                 }
  218.                 if(kk==2)
  219.                 {
  220.                         if(kup==0)
  221.                         {
  222.                                 delay(100);
  223.                                 if(kup==0)
  224.                                 {
  225.                                         ps2++;if(ps2>=10)ps2=0;
  226.                                         WriteCMD(0x80+0x4a);
  227.                                         WriteDAT(0x30+ps2);
  228.                                         WriteCMD(0x80+0x4a);
  229.                                         WriteCMD(0x0e);
  230.                                 }
  231.                         }
  232.                         if(kdown==0)
  233.                         {
  234.                                 delay(100);
  235.                                 if(kdown==0)
  236.                                 {
  237.                                         if(ps2>0)ps2--;
  238.                                         else ps2=9;
  239.                                         WriteCMD(0x80+0x4a);
  240.                                         WriteDAT(0x30+ps2);
  241.                                         WriteCMD(0x80+0x4a);
  242.                                         WriteCMD(0x0e);
  243.                                 }
  244.                         }
  245.                 }
  246.                 if(kk==3)
  247.                 {
  248.                         if(kup==0)
  249.                         {
  250.                                 delay(100);
  251.                                 if(kup==0)
  252.                                 {
  253.                                         ps3++;if(ps3>=10)ps3=0;
  254.                                         WriteCMD(0x80+0x4b);
  255.                                         WriteDAT(0x30+ps3);
  256.                                         WriteCMD(0x80+0x4b);
  257.                                         WriteCMD(0x0e);
  258.                                 }
  259.                         }
  260.                         if(kdown==0)
  261.                         {
  262.                                 delay(100);
  263.                                 if(kdown==0)
  264.                                 {
  265.                                         if(ps3>0)ps3--;
  266.                                         else ps3=9;
  267.                                         WriteCMD(0x80+0x4b);
  268.                                         WriteDAT(0x30+ps3);
  269.                                         WriteCMD(0x80+0x4b);
  270.                                         WriteCMD(0x0e);
  271.                                 }
  272.                         }
  273.                 }                        
  274.                 if(kk==4)
  275.                 {
  276.                         if(kup==0)
  277.                         {
  278.                                 delay(100);
  279.                                 if(kup==0)
  280.                                 {
  281.                                         ps4++;if(ps4>=10)ps4=0;
  282.                                         WriteCMD(0x80+0x4c);
  283.                                         WriteDAT(0x30+ps4);
  284.                                         WriteCMD(0x80+0x4c);
  285.                                         WriteCMD(0x0e);
  286.                                 }
  287.                         }
  288.                         if(kdown==0)
  289.                         {
  290.                                 delay(100);
  291.                                 if(kdown==0)
  292.                                 {
  293.                                         if(ps4>0)ps4--;
  294.                                         else ps4=9;
  295.                                         WriteCMD(0x80+0x4c);
  296.                                         WriteDAT(0x30+ps4);
  297.                                         WriteCMD(0x80+0x4c);
  298.                                         WriteCMD(0x0e);
  299.                                 }
  300.                         }
  301.                 }
  302.                 if(kk==5)
  303.                 {
  304.                         if(kup==0)
  305.                         {
  306.                                 delay(100);
  307.                                 if(kup==0)
  308.                                 {
  309.                                         ps5++;if(ps5>=10)ps5=0;
  310.                                         WriteCMD(0x80+0x4d);
  311.                                         WriteDAT(0x30+ps5);
  312.                                         WriteCMD(0x80+0x4d);
  313.                                         WriteCMD(0x0e);
  314.                                 }
  315.                         }
  316.                         if(kdown==0)
  317.                         {
  318.                                 delay(100);
  319.                                 if(kdown==0)
  320.                                 {
  321.                                         if(ps5>0)ps5--;
  322.                                         else ps5=9;
  323.                                         WriteCMD(0x80+0x4d);
  324.                                         WriteDAT(0x30+ps5);
  325.                                         WriteCMD(0x80+0x4d);
  326.                                         WriteCMD(0x0e);
  327.                                 }
  328.                         }
  329.                 }
  330.                 if(kk==6)
  331.                 {
  332.                         if(kup==0)
  333.                         {
  334.                                 delay(100);
  335.                                 if(kup==0)
  336.                                 {
  337.                                         ps6++;if(ps6>=10)ps6=0;
  338.                                         WriteCMD(0x80+0x4e);
  339.                                         WriteDAT(0x30+ps6);
  340.                                         WriteCMD(0x80+0x4e);
  341.                                         WriteCMD(0x0e);
  342.                                 }
  343.                         }
  344.                         if(kdown==0)
  345.                         {
  346.                                 delay(100);
  347.                                 if(kdown==0)
  348.                                 {
  349.                                         if(ps6>0)ps6--;
  350.                                         else ps6=9;
  351.                                         WriteCMD(0x80+0x4e);
  352.                                         WriteDAT(0x30+ps6);
  353.                                         WriteCMD(0x80+0x4e);
  354.                                         WriteCMD(0x0e);
  355.                                 }
  356.                         }
  357.                 }
  358.                 if(kk==7)
  359.                 {
  360.                         if(kup==0)
  361.                         {
  362.                                 delay(100);
  363.                                 if(kup==0)
  364.                                 {
  365.                                         ps7++;if(ps7>=10)ps7=0;
  366.                                         WriteCMD(0x80+0x4f);
  367.                                         WriteDAT(0x30+ps7);
  368.                                         WriteCMD(0x80+0x4f);
  369.                                         WriteCMD(0x0e);
  370.                                 }
  371.                         }
  372.                         if(kdown==0)
  373.                         {
  374.                                 delay(100);
  375.                                 if(kdown==0)
  376.                                 {
  377.                                         if(ps7>0)ps7--;
  378.                                         else ps7=9;
  379.                                         WriteCMD(0x80+0x4f);
  380.                                         WriteDAT(0x30+ps7);
  381.                                         WriteCMD(0x80+0x4f);
  382.                                         WriteCMD(0x0e);
  383.                                 }
  384.                         }
  385.                 }                                                                                
  386.         }
  387. }
  388.  
  389. /*void write_kg(unsigned long date)
  390. {
  391.         unsigned long shi,ge,bai,qian;
  392.         if(date>9999)date=9999;
  393.         qian=date/1000;
  394.         bai=date%1000/100;
  395.         shi=date%100/10;
  396.         ge=date%10;
  397.         WriteCMD(0x80+0x42);
  398.         WriteDAT(0x30+qian);
  399.         WriteDAT(0x30+bai);
  400.         WriteDAT(0x30+shi);
  401.         WriteDAT(0x30+ge);
  402. }*/
  403.  
  404. void write_kgg(unsigned long date)
  405. {
  406.         unsigned long shi,ge,bai;
  407.         if(date>99999)date=99999;
  408.         (unsigned long)date=(float)date/100;
  409.  
  410.         bai=date/100;
  411.         shi=date%100/10;
  412.         ge=date%10;        
  413.         WriteCMD(0x80+0x43);        
  414.         WriteDAT(0x30+bai);
  415.         WriteDAT(0x30+shi);
  416.         WriteCMD(0x80+0x46);        
  417.         WriteDAT(0x30+ge);        
  418. }
  419.  
  420. void write_n(uint date)
  421. {
  422.         uchar shi,ge,bai;
  423.         bai=date/100;
  424.         shi=date%100/10;
  425.         ge=date%10;
  426.         WriteCMD(0x8d);
  427.         WriteDAT(0x30+bai);
  428.         WriteDAT(0x30+shi);
  429.         WriteDAT(0x30+ge);
  430. }
  431.  
  432. void write_xishu(uint date)
  433. {
  434.         uchar shi,ge;
  435.         shi=date/10;
  436.         ge=date%10;
  437.         WriteCMD(0x80+0x40);
  438.         WriteDAT(0x30+shi);
  439.         WriteDAT(0x30+ge);
  440. }
  441.  
  442. void delay_us(uint z)
  443. {
  444.         while(z--);
  445. }
  446.  
  447. /*unsigned long get_kg(void)
  448. {  
  449.         unsigned long Count;  
  450.         unsigned char i;  
  451.         ADDO=1;
  452.         delay_us(2);        
  453.         ADSK=0;       //使能AD（PD_SCK 置低）  
  454.         Count=0;  
  455.         while(ADDO);    //AD转换未结束则等待，否则开始读取  
  456.         for (i=0;i<24;i++)  
  457.         {   
  458.                 ADSK=1;     //PD_SCK 置高（发送脉冲）   
  459.                 Count=Count<<1; //下降沿来时变量Count左移一位，右侧补零   
  460.                 ADSK=0;     //PD_SCK 置低   
  461.                 if(ADDO)
  462.                 Count++;  
  463.         }  
  464.         ADSK=1;  
  465.         Count=Count^0x800000;//第25个脉冲下降沿来时，转换数据
  466.         delay_us(2);  
  467.         ADSK=0;  
  469.         shiwu=Count/100-gu;
  470.         //shiwu=(unsigned int)((float)shiwu/4.22+0.05);
  471.         return(shiwu);
  472. }*/
  473.  
  474. unsigned long hx711_read(void)
  475. {
  476.         unsigned long Count;  
  477.         unsigned char i;  
  478.         ADDO=1;
  479.         delay_us(2);
  480.         ADSK=0;       //使能AD（PD_SCK 置低）  
  481.         Count=0;  
  482.         while(ADDO);    //AD转换未结束则等待，否则开始读取  
  483.         for (i=0;i<24;i++)  
  484.         {   
  485.                 ADSK=1;     //PD_SCK 置高（发送脉冲）   
  486.                 Count=Count<<1; //下降沿来时变量Count左移一位，右侧补零   
  487.                 ADSK=0;     //PD_SCK 置低   
  488.                 if(ADDO)
  489.                 Count++;  
  490.         }  
  491.         ADSK=1;  
  492.         Count=Count^0x800000;//第25个脉冲下降沿来时，转换数据  
  493.         delay_us(2);
  494.         ADSK=0;  
  495.         return(Count);
  496.  
  497. }
  498.  
  499. void get_maopi()
  500. {
  501.         buf=hx711_read();
  502.         maopi=buf/100;        
  503. }
  504.  
  505. void gei_weight()
  506. {
  507. //        uint n;
  508.         buf=hx711_read();
  509.         buf=buf/100;
  510.         if(buf>maopi)
  511.         {
  512.                 shiwu=buf-maopi;
  513.                 shiwu=(unsigned long)((double)shiwu*xishu/10.0);
  514.                 //shiwu=(unsigned int)((float)shiwu/3.0+0.05);            //需要矫正4.22数值        
  515.         }
  516.         if(shiwu>99000||buf<maopi-30)
  517.         {
  518.                 write_n(999);
  519.                 while(1);
  520.         }
  521.         //shiwu-=(gu/10);        
  522. }
  523.  
  524. void scankey()
  525. {
  526.         uchar num;
  527.         if(kset==0)
  528.         {
  529.                 delay(10);
  530.                 if(kset==0)
  531.                 {
  532.                         key++;
  533.                         while(kset==0);
  534.                         write_xishu(xishu);
  535.                         switch (key)
  536.                         {
  537.                                 case 1 : WriteCMD(0x80+0x4f);WriteCMD(0x0f); break;
  538.                                 case 2 : WriteCMD(0x80+0x41); break;
  539.                                 case 3 : WriteCMD(0x80+0x40);                        
  540.                                         for(num=0;num<5;num++)
  541.                                         {
  542.                                                 WriteDAT(set2[num]);                                       
  543.                                                 delay(20);
  544.                                         }key=0;        WriteCMD(0x0c);break;
  545.                         }
  546.                 }
  547.         }
  548.                         
  549.         if(key==1)
  550.         {
  551.                 if(kup==0)
  552.                 {
  553.                         delay(10);
  554.                         if(kup==0)
  555.                         {
  556.                                 set_num++;if(set_num>=2)set_num=0;
  557.                                 while(!kup);
  558.                                 WriteCMD(0x80+0x4b);
  559.                                 for(num=0;num<5;num++)
  560.                                 {
  561.                                         if(set_num==0)
  562.                                         {WriteDAT(set1[num]);flag=1;}
  563.                                         if(set_num==1)
  564.                                         {WriteDAT(set2[num]);flag=0;}                                                                                
  565.                                         delay(20);
  566.                                 }
  567.                                 WriteCMD(0x80+0x4f);
  568.                                 WriteCMD(0x0f);
  569.                         }
  570.                 }
  571.                 if(kdown==0)
  572.                 {
  573.                         delay(10);
  574.                         if(kdown==0)
  575.                         {
  576.                                 set_num--;if(set_num<0)set_num=1;
  577.                                 while(!kdown);
  578.                                 WriteCMD(0x80+0x4b);
  579.                                 for(num=0;num<5;num++)
  580.                                 {
  581.                                         if(set_num==0)
  582.                                         {WriteDAT(set1[num]);flag=1;}
  583.                                         if(set_num==1)
  584.                                         {WriteDAT(set2[num]);flag=0;}                                                
  585.                                         delay(20);
  586.                                 }
  587.                                 WriteCMD(0x80+0x4f);
  588.                                 WriteCMD(0x0f);
  589.                         }
  590.                 }
  591.         }
  592.         if(key==2)
  593.         {
  594.                 if(kup==0)
  595.                 {
  596.                         delay(10);
  597.                         if(kup==0)
  598.                         {
  599.                                 xishu++;if(xishu>=99)xishu=0;
  600.                                 write_xishu(xishu);
  601.                                 WriteCMD(0x80+0x41);
  602.                                 WriteCMD(0x0f);
  603.                         }
  604.                 }
  605.                 if(kdown==0)
  606.                 {
  607.                         delay(10);
  608.                         if(kdown==0)
  609.                         {
  610.                                 xishu--;if(xishu<0)xishu=99;
  611.                                 write_xishu(xishu);
  612.                                 WriteCMD(0x80+0x41);
  613.                                 WriteCMD(0x0f);
  614.                         }
  615.                 }
  616.         }               
  617. }
  618.  
  619. void bobao()
  620. {
  621.         uint buff;
  622.         uchar ge,shi,bai;

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/706884
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号