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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 带语音播报的51单片机电子体重秤设计(源码+原理图+资料)
12下一页
返回列表 发新帖
查看: 24146|回复: 52
打印 上一主题 下一主题
收起左侧

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

  [复制链接]
跳转到指定楼层
楼主
ID:126172 发表于 2018-5-20 08:37 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
一、要求与目的：
1、实现0~150KG的量程称量；
2、实时显示称量结果在1602上；
3、最小误差为0.01KG；
4、称量体重或物体时待结果稳定后，实现语音播报结果；
5、语音播报可手动关闭或打开；
6、由于传感器一致性差异，体重计算的系数可手动调节。

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

三、实物照片：

四、原理图：



JQ8900-16P语音模块原理图：


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



五、源代码和模块资料（附件中）


单片机源程序如下:
  1. #include <reg52.H>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. #define PX_1602 P1

  6. sbit RS =P3^2;               
  7. sbit RW =P3^3;
  8. sbit E  =P3^4;

  10. /*sbit RS =P1^3;               
  11. sbit RW =P1^4;
  12. sbit E  =P1^5;*/

  14. sbit kset =P2^0;
  15. sbit kup  =P2^2;
  16. sbit kdown=P2^1;

  18. sbit ADDO = P2^4;
  19. sbit ADSK = P2^3;

  21. sbit sda =P3^5;
  22. sbit busy=P3^6;

  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;

  36. void ddelay(uint cnt)
  37. {
  38.         while(cnt--);
  39. }

  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. }

  48. void Delay1us (uint T )
  49. {
  50.     while ( T-- );
  51. }

  53. void SendData (uchar addr)
  54. {
  55.     uchar i;

  57.     EA = 0;

  59.     sda = 1;
  60.     Delay1us ( 1000 );
  61.     sda = 0;
  62.     Delay1us ( 420 );

  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. }

  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. }

  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);      

  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. }

  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);

  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. }

  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. }*/

  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;

  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. }

  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. }

  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. }

  442. void delay_us(uint z)
  443. {
  444.         while(z--);
  445. }

  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. }*/

  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);

  497. }

  499. void get_maopi()
  500. {
  501.         buf=hx711_read();
  502.         maopi=buf/100;        
  503. }

  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. }

  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. }

  619. void bobao()
  620. {
  621.         uint buff;
  622.         uchar ge,shi,bai;
  623. ……………………

  625. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
JQ8900-16P语音模块资料包V1.1.rar (6.8 MB, 下载次数: 415)
Realplay+HX711模块称重传感器专用24位精度AD模块+压力传感器.rar (3.94 MB, 下载次数: 365)
电子秤+语言播报_程序.zip (63.11 KB, 下载次数: 500)


评分

参与人数 3黑币 +60 收起 理由
小学僧 + 5 共享资料的黑币奖励！
1031639928 + 5 很给力！
admin + 50 共享资料的黑币奖励！

查看全部评分

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

使用道具 举报

沙发
ID:270495 发表于 2018-6-8 13:27 | 只看该作者
三个按键有什么作用的呢？
回复

使用道具 举报

板凳
ID:379871 发表于 2018-7-27 15:51 | 只看该作者
你好，请教一下您这个能不能实现实时的语音播报，我在做电子秤
回复

使用道具 举报

地板
ID:276761 发表于 2018-7-27 18:18 | 只看该作者
学习下      
回复

使用道具 举报

5#
ID:247623 发表于 2018-8-9 15:49 | 只看该作者
没有仿真图
回复

使用道具 举报

6#
ID:126172 发表于 2018-9-6 14:34 来自手机 | 只看该作者
女神 发表于 2018-6-8 13:27
三个按键有什么作用的呢？

按键可以输入称重系数，设置声音开关，输入密码等等。
回复

使用道具 举报

7#
ID:126172 发表于 2018-9-6 14:35 来自手机 | 只看该作者
像我这样的华 发表于 2018-7-27 15:51
你好，请教一下您这个能不能实现实时的语音播报，我在做电子秤

这个就是实时的语音播报
回复

使用道具 举报

8#
ID:126172 发表于 2018-9-6 14:37 来自手机 | 只看该作者
yilinghai 发表于 2018-8-9 15:49
没有仿真图

仿真里面没有称重芯片和语音芯片，用别的模拟的话就没什么东西好弄了。
回复

使用道具 举报

9#
ID:341813 发表于 2018-9-16 15:47 | 只看该作者
15个黑币，你可不能蒙我
回复

使用道具 举报

10#
ID:410265 发表于 2018-10-15 22:51 | 只看该作者
赶紧去赚黑币下载
回复

使用道具 举报

11#
ID:410265 发表于 2018-10-15 22:52 | 只看该作者
还有其他模块的原理图加程序，嘤嘤嘤
回复

使用道具 举报

12#
ID:110278 发表于 2018-10-17 15:33 | 只看该作者
资料齐全，完美。
回复

使用道具 举报

13#
ID:247623 发表于 2018-10-18 07:28 来自手机 | 只看该作者
先下来看看
回复

使用道具 举报

14#
ID:413179 发表于 2018-10-24 15:33 | 只看该作者
怎么下面的资料不包括总的原理图？？？？
回复

使用道具 举报

15#
ID:413179 发表于 2018-10-24 15:37 | 只看该作者
需要原理图或者仿真图
回复

使用道具 举报

16#
ID:126172 发表于 2018-10-25 22:32 | 只看该作者
我活着哎1 发表于 2018-9-16 15:47
15个黑币，你可不能蒙我

没有蒙人哦，这个我已经制作成功了才发出来的，有需要帮助的可以加我
回复

使用道具 举报

17#
ID:126172 发表于 2018-10-25 22:35 | 只看该作者
前来报到 发表于 2018-10-24 15:37
需要原理图或者仿真图

我发的时候应该是一整个包，这里展示细分了
回复

使用道具 举报

18#
ID:421761 发表于 2018-11-8 23:54 来自手机 | 只看该作者
可以的，大神，正好用
回复

使用道具 举报

19#
ID:317175 发表于 2018-12-26 17:45 | 只看该作者
大神，能分享一下总的原理图吗？
回复

使用道具 举报

20#
ID:452548 发表于 2019-1-3 19:53 | 只看该作者
很给力！
回复

使用道具 举报

21#
ID:462197 发表于 2019-1-4 23:25 | 只看该作者
老哥，原理图能发我下吗，你的qq找不到
回复

使用道具 举报

22#
ID:462302 发表于 2019-1-5 10:17 来自手机 | 只看该作者
太棒了
回复

使用道具 举报

23#
ID:73202 发表于 2019-1-5 17:45 | 只看该作者
确实不错哦好东西，谢谢分享
回复

使用道具 举报

24#
ID:473928 发表于 2019-2-16 18:08 | 只看该作者
感谢分享，下载学习
回复

使用道具 举报

25#
ID:473928 发表于 2019-2-16 22:59 | 只看该作者
你好，下载了，就是没有一份总的原理图，不知道能不能发我一份 ，多谢了   jason.gj@foxmail.com
回复

使用道具 举报

26#
ID:130345 发表于 2019-2-27 23:38 | 只看该作者
太谢谢了
回复

使用道具 举报

27#
ID:468603 发表于 2019-3-1 20:38 | 只看该作者
可以给份完整原理图吗，下了没法用
as.59@qq.com
回复

使用道具 举报

28#
ID:130345 发表于 2019-3-3 23:56 | 只看该作者
wen-zi 发表于 2018-9-6 14:35
这个就是实时的语音播报

楼主您好，请问您有在语音模块里面存储什么内容吗？
回复

使用道具 举报

29#
ID:156220 发表于 2019-3-4 09:47 | 只看该作者
谢谢资料分享
回复

使用道具 举报

30#
ID:486879 发表于 2019-3-15 15:46 | 只看该作者
做出来的成品误差怎么样
回复

使用道具 举报

31#
ID:103442 发表于 2019-3-31 17:32 | 只看该作者
学习一下
回复

使用道具 举报

32#
ID:501878 发表于 2019-3-31 17:58 | 只看该作者
学习一下
回复

使用道具 举报

33#
ID:464689 发表于 2019-3-31 19:57 来自手机 | 只看该作者
厉害了
回复

使用道具 举报

34#
ID:73182 发表于 2019-4-1 11:05 | 只看该作者
感谢分享
回复

使用道具 举报

35#
ID:506687 发表于 2019-4-8 17:38 | 只看该作者
请问这个有详细的材料清单吗？
回复

使用道具 举报

36#
ID:432611 发表于 2019-4-21 16:22 | 只看该作者
正想用这个模块
回复

使用道具 举报

37#
ID:126172 发表于 2019-5-15 10:18 | 只看该作者
StaryLL 发表于 2019-4-8 17:38
请问这个有详细的材料清单吗？

帖子最前面就是详细的清单
回复

使用道具 举报

38#
ID:549278 发表于 2019-5-28 15:08 | 只看该作者
语音播报，我在做电子秤
回复

使用道具 举报

39#
ID:551041 发表于 2019-5-30 14:23 | 只看该作者
顶一下楼主，
回复

使用道具 举报

40#
ID:544894 发表于 2019-6-6 07:22 | 只看该作者
有人有这个的连接原理图吗？Q1326657247，万分感谢
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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