单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 5916|回复: 35
收起左侧

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

  [复制链接]
wen-zi 发表于 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、洞洞板、下载线、晶振、电容、电阻、按键、排针等

三、实物照片:
电子体重秤(语音播报)2.jpg 电子体重秤(语音播报)1.jpg 电子体重秤(语音播报)2.jpg 电子体重秤(语音播报)1.jpg
四、原理图:
电子秤原理图.png


JQ8900-16P语音模块原理图:
0.png

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

五、源代码和模块资料(附件中)
0.png

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

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

  8. /*sbit RS =P1^3;               
  9. sbit RW =P1^4;
  10. sbit E  =P1^5;*/

  11. sbit kset =P2^0;
  12. sbit kup  =P2^2;
  13. sbit kdown=P2^1;

  14. sbit ADDO = P2^4;
  15. sbit ADSK = P2^3;

  16. sbit sda =P3^5;
  17. sbit busy=P3^6;

  18. uchar code str1[]={"Test weight:         "};
  19. uchar code str2[]={"   00.0Kg  Voice"};
  20. uchar code str11[]={"Welcome to use"};
  21. uchar code str22[]={"Password:"};
  22. uchar code set1[]={"Voice"};
  23. uchar code set2[10]={"      "};
  24. unsigned long buf=0,maopi=0,shiwu=0,shiwu2=0,shiwu_buf=0,gu=84866;
  25. uchar  key,TSS,flag=0;
  26. uint t;
  27. int set_num,xishu=38;
  28. double kg;

  29. void ddelay(uint cnt)
  30. {
  31.         while(cnt--);
  32. }

  33. void delay(uint z)
  34. {
  35.         uint x,y;
  36.         for(x=z;x>0;x--)
  37.            for(y=110;y>0;y--);        
  38. }

  39. void Delay1us (uint T )
  40. {
  41.     while ( T-- );
  42. }

  43. void SendData (uchar addr)
  44. {
  45.     uchar i;

  46.     EA = 0;

  47.     sda = 1;
  48.     Delay1us ( 1000 );
  49.     sda = 0;
  50.     Delay1us ( 420 );

  51.     for ( i = 0; i < 8; i++ )
  52.     {
  53.         sda = 1;
  54.         if ( addr & 0x01 )
  55.         {
  56.             Delay1us ( 300 );
  57.             sda = 0;
  58.             Delay1us ( 100 );
  59.         }
  60.         else      
  61.         {
  62.             Delay1us ( 100 );
  63.             sda = 0;
  64.             Delay1us ( 300 );
  65.         }
  66.         addr >>= 1;
  67.     }
  68.     sda = 1;
  69.     EA = 1;//????
  70. }
  71.                
  72. void WriteCMD(uchar command)               
  73. {
  74.         RS = 0;
  75.         RW = 0;
  76.         ddelay(20);
  77.         E = 1;
  78.         ddelay(20);
  79.         PX_1602 = command;
  80.         ddelay(30);
  81.         E = 0;
  82.         ddelay(50);
  83. }

  84. void WriteDAT(uchar dat)               
  85. {
  86.         RS = 1;
  87.         RW = 0;
  88.         ddelay(20);
  89.         E = 1;
  90.         ddelay(20);
  91.         PX_1602 = dat;
  92.         ddelay(30);
  93.         E = 0;
  94.         ddelay(50);
  95. }

  96. void init_1602()                  
  97. {
  98.         uchar num;
  99.         E=0;
  100.         WriteCMD(0x38);
  101.         WriteCMD(0x38);         
  102.         WriteCMD(0x0c);        
  103.         WriteCMD(0x06);      
  104.         WriteCMD(0x01);        
  105.         WriteCMD(0x80);      

  106.   for(num=0;num<16;num++)
  107.         {
  108.                 WriteDAT(str1[num]);
  109.                 //if(num==4){WriteCMD(0x80+4);WriteDAT(0xd0+15);}        
  110.                 delay(20);
  111.   }
  112.         
  113.         WriteCMD(0x80+0x40);
  114.         for(num=0;num<16;num++)
  115.         {
  116.                 WriteDAT(str2[num]);
  117.                 delay(20);
  118.           }
  119.         delay(200);                                  //yan shi 100us(12Mjingzheng)
  120. }

  121. void password()
  122. {
  123.         uchar num,kk=1;
  124.         uchar ps1,ps2,ps3,ps4,ps5,ps6,ps7;
  125.         E=1;
  126.         WriteCMD(0x38);
  127.         WriteCMD(0x38);         
  128.         WriteCMD(0x0c);        
  129.         WriteCMD(0x06);      
  130.         WriteCMD(0x01);        
  131.         WriteCMD(0x80);

  132.   for(num=0;num<14;num++)
  133.         {
  134.                 WriteDAT(str11[num]);
  135.                 delay(20);
  136.   }        
  137.         WriteCMD(0x80+0x40);
  138.         for(num=0;num<9;num++)
  139.         {
  140.                 WriteDAT(str22[num]);
  141.                 delay(20);
  142.           }
  143.         delay(200);                                  //yan shi 100us(12Mjingzheng)
  144.         WriteCMD(0x80+0x49);
  145.         WriteCMD(0x0f);
  146.         while(1)
  147.         {
  148.                 if(kset==0)
  149.                 {
  150.                         delay(10);
  151.                         if(kset==0)
  152.                         {
  153.                                 kk++;
  154.                                 while(kset==0);
  155.                                 WriteCMD(0x0f);
  156.                                 switch (kk)
  157.                                 {
  158.                                         case 1 : WriteCMD(0x80+0x49); break;
  159.                                         case 2 : WriteCMD(0x80+0x4a); break;
  160.                                         case 3 : WriteCMD(0x80+0x4b); break;
  161.                                         case 4 : WriteCMD(0x80+0x4c); break;
  162.                                         case 5 : WriteCMD(0x80+0x4d); break;
  163.                                         case 6 : WriteCMD(0x80+0x4e); break;
  164.                                         case 7 : WriteCMD(0x80+0x4f); break;
  165.                                         case 8 : kk=1;WriteCMD(0x80+0x49); break;
  166.                                 }
  167.                         }
  168.                 }
  169.                 if(kk==1)
  170.                 {
  171.                         if(ps1==2&&ps2==0&&ps3==1&&ps4==8&&ps5==6&&ps6==6&&ps7==6)break;
  172.                         if(kup==0)
  173.                         {
  174.                                 delay(100);
  175.                                 if(kup==0)
  176.                                 {
  177.                                         if(kdown==0)break;
  178.                                         ps1++;if(ps1>=10)ps1=0;
  179.                                         WriteCMD(0x80+0x49);
  180.                                         WriteDAT(0x30+ps1);
  181.                                         WriteCMD(0x80+0x49);
  182.                                         WriteCMD(0x0e);
  183.                                 }
  184.                         }
  185.                         if(kdown==0)
  186.                         {
  187.                                 delay(100);
  188.                                 if(kdown==0)
  189.                                 {
  190.                                         if(kup==0)break;
  191.                                         if(ps1>0)ps1--;
  192.                                         else ps1=9;
  193.                                         WriteCMD(0x80+0x49);
  194.                                         WriteDAT(0x30+ps1);
  195.                                         WriteCMD(0x80+0x49);
  196.                                         WriteCMD(0x0e);
  197.                                 }
  198.                         }
  199.                 }
  200.                 if(kk==2)
  201.                 {
  202.                         if(kup==0)
  203.                         {
  204.                                 delay(100);
  205.                                 if(kup==0)
  206.                                 {
  207.                                         ps2++;if(ps2>=10)ps2=0;
  208.                                         WriteCMD(0x80+0x4a);
  209.                                         WriteDAT(0x30+ps2);
  210.                                         WriteCMD(0x80+0x4a);
  211.                                         WriteCMD(0x0e);
  212.                                 }
  213.                         }
  214.                         if(kdown==0)
  215.                         {
  216.                                 delay(100);
  217.                                 if(kdown==0)
  218.                                 {
  219.                                         if(ps2>0)ps2--;
  220.                                         else ps2=9;
  221.                                         WriteCMD(0x80+0x4a);
  222.                                         WriteDAT(0x30+ps2);
  223.                                         WriteCMD(0x80+0x4a);
  224.                                         WriteCMD(0x0e);
  225.                                 }
  226.                         }
  227.                 }
  228.                 if(kk==3)
  229.                 {
  230.                         if(kup==0)
  231.                         {
  232.                                 delay(100);
  233.                                 if(kup==0)
  234.                                 {
  235.                                         ps3++;if(ps3>=10)ps3=0;
  236.                                         WriteCMD(0x80+0x4b);
  237.                                         WriteDAT(0x30+ps3);
  238.                                         WriteCMD(0x80+0x4b);
  239.                                         WriteCMD(0x0e);
  240.                                 }
  241.                         }
  242.                         if(kdown==0)
  243.                         {
  244.                                 delay(100);
  245.                                 if(kdown==0)
  246.                                 {
  247.                                         if(ps3>0)ps3--;
  248.                                         else ps3=9;
  249.                                         WriteCMD(0x80+0x4b);
  250.                                         WriteDAT(0x30+ps3);
  251.                                         WriteCMD(0x80+0x4b);
  252.                                         WriteCMD(0x0e);
  253.                                 }
  254.                         }
  255.                 }                        
  256.                 if(kk==4)
  257.                 {
  258.                         if(kup==0)
  259.                         {
  260.                                 delay(100);
  261.                                 if(kup==0)
  262.                                 {
  263.                                         ps4++;if(ps4>=10)ps4=0;
  264.                                         WriteCMD(0x80+0x4c);
  265.                                         WriteDAT(0x30+ps4);
  266.                                         WriteCMD(0x80+0x4c);
  267.                                         WriteCMD(0x0e);
  268.                                 }
  269.                         }
  270.                         if(kdown==0)
  271.                         {
  272.                                 delay(100);
  273.                                 if(kdown==0)
  274.                                 {
  275.                                         if(ps4>0)ps4--;
  276.                                         else ps4=9;
  277.                                         WriteCMD(0x80+0x4c);
  278.                                         WriteDAT(0x30+ps4);
  279.                                         WriteCMD(0x80+0x4c);
  280.                                         WriteCMD(0x0e);
  281.                                 }
  282.                         }
  283.                 }
  284.                 if(kk==5)
  285.                 {
  286.                         if(kup==0)
  287.                         {
  288.                                 delay(100);
  289.                                 if(kup==0)
  290.                                 {
  291.                                         ps5++;if(ps5>=10)ps5=0;
  292.                                         WriteCMD(0x80+0x4d);
  293.                                         WriteDAT(0x30+ps5);
  294.                                         WriteCMD(0x80+0x4d);
  295.                                         WriteCMD(0x0e);
  296.                                 }
  297.                         }
  298.                         if(kdown==0)
  299.                         {
  300.                                 delay(100);
  301.                                 if(kdown==0)
  302.                                 {
  303.                                         if(ps5>0)ps5--;
  304.                                         else ps5=9;
  305.                                         WriteCMD(0x80+0x4d);
  306.                                         WriteDAT(0x30+ps5);
  307.                                         WriteCMD(0x80+0x4d);
  308.                                         WriteCMD(0x0e);
  309.                                 }
  310.                         }
  311.                 }
  312.                 if(kk==6)
  313.                 {
  314.                         if(kup==0)
  315.                         {
  316.                                 delay(100);
  317.                                 if(kup==0)
  318.                                 {
  319.                                         ps6++;if(ps6>=10)ps6=0;
  320.                                         WriteCMD(0x80+0x4e);
  321.                                         WriteDAT(0x30+ps6);
  322.                                         WriteCMD(0x80+0x4e);
  323.                                         WriteCMD(0x0e);
  324.                                 }
  325.                         }
  326.                         if(kdown==0)
  327.                         {
  328.                                 delay(100);
  329.                                 if(kdown==0)
  330.                                 {
  331.                                         if(ps6>0)ps6--;
  332.                                         else ps6=9;
  333.                                         WriteCMD(0x80+0x4e);
  334.                                         WriteDAT(0x30+ps6);
  335.                                         WriteCMD(0x80+0x4e);
  336.                                         WriteCMD(0x0e);
  337.                                 }
  338.                         }
  339.                 }
  340.                 if(kk==7)
  341.                 {
  342.                         if(kup==0)
  343.                         {
  344.                                 delay(100);
  345.                                 if(kup==0)
  346.                                 {
  347.                                         ps7++;if(ps7>=10)ps7=0;
  348.                                         WriteCMD(0x80+0x4f);
  349.                                         WriteDAT(0x30+ps7);
  350.                                         WriteCMD(0x80+0x4f);
  351.                                         WriteCMD(0x0e);
  352.                                 }
  353.                         }
  354.                         if(kdown==0)
  355.                         {
  356.                                 delay(100);
  357.                                 if(kdown==0)
  358.                                 {
  359.                                         if(ps7>0)ps7--;
  360.                                         else ps7=9;
  361.                                         WriteCMD(0x80+0x4f);
  362.                                         WriteDAT(0x30+ps7);
  363.                                         WriteCMD(0x80+0x4f);
  364.                                         WriteCMD(0x0e);
  365.                                 }
  366.                         }
  367.                 }                                                                                
  368.         }
  369. }

  370. /*void write_kg(unsigned long date)
  371. {
  372.         unsigned long shi,ge,bai,qian;
  373.         if(date>9999)date=9999;
  374.         qian=date/1000;
  375.         bai=date%1000/100;
  376.         shi=date%100/10;
  377.         ge=date%10;
  378.         WriteCMD(0x80+0x42);
  379.         WriteDAT(0x30+qian);
  380.         WriteDAT(0x30+bai);
  381.         WriteDAT(0x30+shi);
  382.         WriteDAT(0x30+ge);
  383. }*/

  384. void write_kgg(unsigned long date)
  385. {
  386.         unsigned long shi,ge,bai;
  387.         if(date>99999)date=99999;
  388.         (unsigned long)date=(float)date/100;

  389.         bai=date/100;
  390.         shi=date%100/10;
  391.         ge=date%10;        
  392.         WriteCMD(0x80+0x43);        
  393.         WriteDAT(0x30+bai);
  394.         WriteDAT(0x30+shi);
  395.         WriteCMD(0x80+0x46);        
  396.         WriteDAT(0x30+ge);        
  397. }

  398. void write_n(uint date)
  399. {
  400.         uchar shi,ge,bai;
  401.         bai=date/100;
  402.         shi=date%100/10;
  403.         ge=date%10;
  404.         WriteCMD(0x8d);
  405.         WriteDAT(0x30+bai);
  406.         WriteDAT(0x30+shi);
  407.         WriteDAT(0x30+ge);
  408. }

  409. void write_xishu(uint date)
  410. {
  411.         uchar shi,ge;
  412.         shi=date/10;
  413.         ge=date%10;
  414.         WriteCMD(0x80+0x40);
  415.         WriteDAT(0x30+shi);
  416.         WriteDAT(0x30+ge);
  417. }

  418. void delay_us(uint z)
  419. {
  420.         while(z--);
  421. }

  422. /*unsigned long get_kg(void)
  423. {  
  424.         unsigned long Count;  
  425.         unsigned char i;  
  426.         ADDO=1;
  427.         delay_us(2);        
  428.         ADSK=0;       //使能AD(PD_SCK 置低)  
  429.         Count=0;  
  430.         while(ADDO);    //AD转换未结束则等待,否则开始读取  
  431.         for (i=0;i<24;i++)  
  432.         {   
  433.                 ADSK=1;     //PD_SCK 置高(发送脉冲)   
  434.                 Count=Count<<1; //下降沿来时变量Count左移一位,右侧补零   
  435.                 ADSK=0;     //PD_SCK 置低   
  436.                 if(ADDO)
  437.                 Count++;  
  438.         }  
  439.         ADSK=1;  
  440.         Count=Count^0x800000;//第25个脉冲下降沿来时,转换数据
  441.         delay_us(2);  
  442.         ADSK=0;  

  443.         shiwu=Count/100-gu;
  444.         //shiwu=(unsigned int)((float)shiwu/4.22+0.05);
  445.         return(shiwu);
  446. }*/

  447. unsigned long hx711_read(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;  
  468.         return(Count);

  469. }

  470. void get_maopi()
  471. {
  472.         buf=hx711_read();
  473.         maopi=buf/100;        
  474. }

  475. void gei_weight()
  476. {
  477. //        uint n;
  478.         buf=hx711_read();
  479.         buf=buf/100;
  480.         if(buf>maopi)
  481.         {
  482.                 shiwu=buf-maopi;
  483.                 shiwu=(unsigned long)((double)shiwu*xishu/10.0);
  484.                 //shiwu=(unsigned int)((float)shiwu/3.0+0.05);            //需要矫正4.22数值        
  485.         }
  486.         if(shiwu>99000||buf<maopi-30)
  487.         {
  488.                 write_n(999);
  489.                 while(1);
  490.         }
  491.         //shiwu-=(gu/10);        
  492. }

  493. void scankey()
  494. {
  495.         uchar num;
  496.         if(kset==0)
  497.         {
  498.                 delay(10);
  499.                 if(kset==0)
  500.                 {
  501.                         key++;
  502.                         while(kset==0);
  503.                         write_xishu(xishu);
  504.                         switch (key)
  505.                         {
  506.                                 case 1 : WriteCMD(0x80+0x4f);WriteCMD(0x0f); break;
  507.                                 case 2 : WriteCMD(0x80+0x41); break;
  508.                                 case 3 : WriteCMD(0x80+0x40);                        
  509.                                         for(num=0;num<5;num++)
  510.                                         {
  511.                                                 WriteDAT(set2[num]);                                       
  512.                                                 delay(20);
  513.                                         }key=0;        WriteCMD(0x0c);break;
  514.                         }
  515.                 }
  516.         }
  517.                         
  518.         if(key==1)
  519.         {
  520.                 if(kup==0)
  521.                 {
  522.                         delay(10);
  523.                         if(kup==0)
  524.                         {
  525.                                 set_num++;if(set_num>=2)set_num=0;
  526.                                 while(!kup);
  527.                                 WriteCMD(0x80+0x4b);
  528.                                 for(num=0;num<5;num++)
  529.                                 {
  530.                                         if(set_num==0)
  531.                                         {WriteDAT(set1[num]);flag=1;}
  532.                                         if(set_num==1)
  533.                                         {WriteDAT(set2[num]);flag=0;}                                                                                
  534.                                         delay(20);
  535.                                 }
  536.                                 WriteCMD(0x80+0x4f);
  537.                                 WriteCMD(0x0f);
  538.                         }
  539.                 }
  540.                 if(kdown==0)
  541.                 {
  542.                         delay(10);
  543.                         if(kdown==0)
  544.                         {
  545.                                 set_num--;if(set_num<0)set_num=1;
  546.                                 while(!kdown);
  547.                                 WriteCMD(0x80+0x4b);
  548.                                 for(num=0;num<5;num++)
  549.                                 {
  550.                                         if(set_num==0)
  551.                                         {WriteDAT(set1[num]);flag=1;}
  552.                                         if(set_num==1)
  553.                                         {WriteDAT(set2[num]);flag=0;}                                                
  554.                                         delay(20);
  555.                                 }
  556.                                 WriteCMD(0x80+0x4f);
  557.                                 WriteCMD(0x0f);
  558.                         }
  559.                 }
  560.         }
  561.         if(key==2)
  562.         {
  563.                 if(kup==0)
  564.                 {
  565.                         delay(10);
  566.                         if(kup==0)
  567.                         {
  568.                                 xishu++;if(xishu>=99)xishu=0;
  569.                                 write_xishu(xishu);
  570.                                 WriteCMD(0x80+0x41);
  571.                                 WriteCMD(0x0f);
  572.                         }
  573.                 }
  574.                 if(kdown==0)
  575.                 {
  576.                         delay(10);
  577.                         if(kdown==0)
  578.                         {
  579.                                 xishu--;if(xishu<0)xishu=99;
  580.                                 write_xishu(xishu);
  581.                                 WriteCMD(0x80+0x41);
  582.                                 WriteCMD(0x0f);
  583.                         }
  584.                 }
  585.         }               
  586. }

  587. void bobao()
  588. {
  589.         uint buff;
  590.         uchar ge,shi,bai;
  591. ……………………

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

所有资料51hei提供下载:
JQ8900-16P语音模块资料包V1.1.rar (6.8 MB, 下载次数: 168)

评分

参与人数 2黑币 +55 收起 理由
1031639928 + 5 很给力!
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

女神 发表于 2018-6-8 13:27 | 显示全部楼层
三个按键有什么作用的呢?
回复

使用道具 举报

像我这样的华 发表于 2018-7-27 15:51 | 显示全部楼层
你好,请教一下您这个能不能实现实时的语音播报,我在做电子秤
回复

使用道具 举报

cliang223 发表于 2018-7-27 18:18 | 显示全部楼层
学习下      
回复

使用道具 举报

yilinghai 发表于 2018-8-9 15:49 | 显示全部楼层
没有仿真图
回复

使用道具 举报

 楼主| wen-zi 发表于 2018-9-6 14:34 来自手机 | 显示全部楼层
女神 发表于 2018-6-8 13:27
三个按键有什么作用的呢?

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

使用道具 举报

 楼主| wen-zi 发表于 2018-9-6 14:35 来自手机 | 显示全部楼层
像我这样的华 发表于 2018-7-27 15:51
你好,请教一下您这个能不能实现实时的语音播报,我在做电子秤

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

使用道具 举报

 楼主| wen-zi 发表于 2018-9-6 14:37 来自手机 | 显示全部楼层
yilinghai 发表于 2018-8-9 15:49
没有仿真图

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

使用道具 举报

我活着哎1 发表于 2018-9-16 15:47 | 显示全部楼层
15个黑币,你可不能蒙我
回复

使用道具 举报

草由八 发表于 2018-10-15 22:51 | 显示全部楼层
大佬没有东西下载权限阿喵。能不能私发一下我大秋秋1662145023QvQ
回复

使用道具 举报

草由八 发表于 2018-10-15 22:52 | 显示全部楼层
还有其他模块的原理图加程序,嘤嘤嘤
回复

使用道具 举报

12#
无效楼层,该帖已经被删除
linnyshow 发表于 2018-10-17 15:33 | 显示全部楼层
资料齐全,完美。
回复

使用道具 举报

yilinghai 发表于 2018-10-18 07:28 来自手机 | 显示全部楼层
先下来看看
回复

使用道具 举报

前来报到 发表于 2018-10-24 15:33 | 显示全部楼层
怎么下面的资料不包括总的原理图????
回复

使用道具 举报

前来报到 发表于 2018-10-24 15:37 | 显示全部楼层
需要原理图或者仿真图
回复

使用道具 举报

 楼主| wen-zi 发表于 2018-10-25 22:32 | 显示全部楼层
我活着哎1 发表于 2018-9-16 15:47
15个黑币,你可不能蒙我

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

使用道具 举报

18#
无效楼层,该帖已经被删除
 楼主| wen-zi 发表于 2018-10-25 22:35 | 显示全部楼层
前来报到 发表于 2018-10-24 15:37
需要原理图或者仿真图

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

使用道具 举报

zl123zl 发表于 2018-10-31 22:09 | 显示全部楼层
大神,上面那个是你QQ吗?可不可以分享一下资料啊,小弟qq2783961908
回复

使用道具 举报

落日。 发表于 2018-11-8 23:54 来自手机 | 显示全部楼层
可以的,大神,正好用
回复

使用道具 举报

T.S 发表于 2018-12-26 17:45 | 显示全部楼层
大神,能分享一下总的原理图吗?
回复

使用道具 举报

myhuang027 发表于 2019-1-3 19:53 | 显示全部楼层
很给力!
回复

使用道具 举报

jgj123456 发表于 2019-1-4 23:25 | 显示全部楼层
老哥,原理图能发我下吗,你的qq找不到
回复

使用道具 举报

LBB 发表于 2019-1-5 10:17 来自手机 | 显示全部楼层
太棒了
回复

使用道具 举报

mcs51 发表于 2019-1-5 17:45 | 显示全部楼层
确实不错哦好东西,谢谢分享
回复

使用道具 举报

ROC黄 发表于 2019-1-22 11:42 | 显示全部楼层
大佬!可以分享一下原理图和程序给我吗?邮箱1663861763@qq.com
回复

使用道具 举报

Jason.gj 发表于 2019-2-16 18:08 | 显示全部楼层
感谢分享,下载学习
回复

使用道具 举报

Jason.gj 发表于 2019-2-16 22:59 | 显示全部楼层
你好,下载了,就是没有一份总的原理图,不知道能不能发我一份 ,多谢了   jason.gj@foxmail.com
回复

使用道具 举报

 楼主| wen-zi 发表于 2019-2-27 22:15 | 显示全部楼层
ROC黄 发表于 2019-1-22 11:42
大佬!可以分享一下原理图和程序给我吗?邮箱

先加我微信吧,15050192251
回复

使用道具 举报

 楼主| wen-zi 发表于 2019-2-27 22:18 | 显示全部楼层
Jason.gj 发表于 2019-2-16 22:59
你好,下载了,就是没有一份总的原理图,不知道能不能发我一份 ,多谢了

有的,可以加个微信,15050192251
回复

使用道具 举报

 楼主| wen-zi 发表于 2019-2-27 22:19 | 显示全部楼层
jgj123456 发表于 2019-1-4 23:25
老哥,原理图能发我下吗,你的qq找不到

加我微信,15050192251
回复

使用道具 举报

持勤补拙 发表于 2019-2-27 23:38 | 显示全部楼层
太谢谢了
回复

使用道具 举报

34#
无效楼层,该帖已经被删除
hahahhah 发表于 2019-3-1 20:38 | 显示全部楼层
可以给份完整原理图吗,下了没法用
as.59@qq.com
回复

使用道具 举报

 楼主| wen-zi 发表于 2019-3-2 17:16 | 显示全部楼层
hahahhah 发表于 2019-3-1 20:38
可以给份完整原理图吗,下了没法用

加微信15050192251吧,不常上论坛
回复

使用道具 举报

持勤补拙 发表于 2019-3-3 23:56 | 显示全部楼层
wen-zi 发表于 2018-9-6 14:35
这个就是实时的语音播报

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

使用道具 举报

紫色的云 发表于 2019-3-4 09:47 | 显示全部楼层
谢谢资料分享
回复

使用道具 举报

巩鑫莹 发表于 2019-3-15 15:46 | 显示全部楼层
做出来的成品误差怎么样
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51黑电子论坛单片机. 联系QQ:125739409;技术交流QQ群582644647

Powered by 单片机教程网

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