HX711电子称完整单片机程序和原理图

HX711电子称原理图：


HX711电子秤使用说明：
商品代码：
0001        香蕉
0002        苹果
0003        橘子
0004        葡萄
0005        柚子
0006        橙子
0007        梨子
0008        西瓜
0009        木瓜
0010        桃子

键盘键位定义：

7        8        9        10(清零)
4        5        6        11(删除)        总金额(P3.7)
1        2        3        12(去皮)
14(累计)0        15(.)        13(确定)

大体流程：
1.连接好传感器及主板各部件，给系统通电
2.通电后，液晶显示第一屏，包括学校、系部、专业、制作人以及作品名称。
3.几秒后，液晶显示第二屏，大体格式是：
名称数量:0000-00
重量：   0.000kg
单价：   0.00 元
金额：------- 元

4.名称数量:0000-00，前面的0000表示商品代码，如上面所示，后面00的代表数量。
例如：输入0001-01，则先按1键，再按小数点，再按0，再按1即输入了0001-01，然后按确定键，则显示香蕉01.
注意：如果输错了，比如是0001-00，按确定键，即清零了，也就是你得重新输入数据。
还有几种情况，也是按确定键自动清零的。比如是0000-01，没有这个商品编码，则出错。
再比如，我们设置的商品代码范围是1-10，则如果输入的商品代码不在范围内，则按确定键即清零，需要重新输入数据。
5.输入完名称数量，再按数字键，则是输入单价，输入单价后，按确定键，则计算出金额，并显示出来。

6.如果不需要累计，下次称重前，按一次清零即可。
如果需要累计，则在商品没有拿下钱，按一次累计，然后拿下商品，再按一次清零即可进行下一次称重。

7.清零前，必须在拿下商品的情况下才能准确回零。

8.去皮功能：先在传感器支架上放上要去皮的，然后按一下去皮键，则重量那显示0kg，表示去皮成功。这时，再放上商品，按操作顺序进行操作。

9.总金额：当累计几次后，需要算总金额时，按一下总金额键，即可算出总金额，并在屏幕显示出来。
再按一次总金额即可清零，回到初始状态。

10.输入数字过程中，如果出错，可以退格，也就类似电脑的backspace，向前删除一位。

11.按键注意事项：按键时间不能过长，也不能过短，按键时间和按键压力一定要适中，这样才能正确读取数据。

HX711电子称部分源程序：

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #include<string.h>
   
4. #include<lcd12864.h>
   
5. #include<hx711.h>
   
6. #include<keyboard.h>
   
7. #define uint unsigned int
   
8. #define uchar unsigned char
   
9. #define ulong unsigned long
   
10. #define delayNOP();{_nop_();_nop_();_nop_();_nop_();};
    
11. //定义量程系数
    
12. #define RATIO     6797/1000   
    
13. //定义标识
    
14. volatile bit FlagTest = 0;                //定时测试标志，每0.5秒置位，测完清0
    
15. volatile bit FlagKeyPress = 0;  //有键按下标志，处理完毕清0
    
16. volatile bit FlagSetPrice = 0;  //价格设置状态标志，设置好为1。
    
17. //管脚定义
    
18. //sbit LedA = P2^2;
    
19. sbit beep = P1^5;
    
20. sbit alert = P1^6;
    
21. sbit key_all=P3^7;        //总金额键
    
22. //显示用变量
    
23. int Counter;
    
24. uchar idata str1[6] = "000000";
    
25. uchar code name0[]={"本次购物总金额："};
    
26. uchar code name1[]={"香蕉"};
    
27. uchar code name2[]={"苹果"};
    
28. uchar code name3[]={"橘子"};
    
29. uchar code name4[]={"葡萄"};
    
30. uchar code name5[]={"柚子"};
    
31. uchar code name6[]={"橙子"};
    
32. uchar code name7[]={"梨子"};
    
33. uchar code name8[]={"西瓜"};
    
34. uchar code name9[]={"木瓜"};
    
35. uchar code name10[]={"桃子"};
    
36. int i, iTemp;
    
37. //称重用变量
    
38. ulong idata FullScale; //满量程AD值/1000
    
39. ulong AdVal;     //AD采样值
    
40. ulong weight;    //重量值，单位g
    
41. ulong idata price;     //单价，长整型值，单位为分   
    
42. ulong idata money;     //总价，长整型值，单位为分
    
43. ulong dec_weight;
    
44. //键盘处理变量
    
45. uchar keycode;
    
46. uchar DotPos;                                   //小数点标志及位置
    
47. uchar Dec_pi;                //去皮变量
    
48. uchar all_flag;                //累计变量
    
49. //标志位
    
50. uchar num_name;                //名称数量标志
    
51. uchar shuliang;                //数量值
    
52. ulong idata all_money;        //累计
    
53. 
    
54. //函数声明
    
55. void int2str(int, char *);
    
56. void Data_Init();
    
57. void Port_Init();  
    
58. void Timer0_Init();
    
59. void Timer0_ISR () ;
    
60. void INT1_Init();
    
61. void KeyPress(uchar);
    
62. void To_Zero();
    
63. void Display_Namenum();
    
64. void Display_Price();
    
65. void Display_Weight();
    
66. void Display_Money();
    
67. void Display_Allmoney();
    
68. //整型转字符串的函数，转换范围0--65536
    
69. void int2str(int x, char* str)
    
70. {
    
71.         int i=1;
    
72.     int tmp=10;
    
73.     while(x/tmp!=0)
    
74.     {
    
75.               i++;
    
76.         tmp*=10;
    
77.     }
    
78.     tmp=x;
    
79.     str[i]='\0';
    
80.     while(i>1)
    
81.     {
    
82.         str[--i]='0'+(tmp%10);
    
83.         tmp/=10;
    
84.     }
    
85.     str[0]=tmp+'0';
    
86. }
    
87. //重新找回零点，每次测量前调用
    
88. void To_Zero()
    
89. {
    
90.            FullScale=ReadCount()/1000;
    
91.            price=0;
    
92. }
    
93. //显示名称数量，单位为元，四位整数，两位小数
    
94. void Display_Namenum()
    
95. {
    
96.            uint i,j;
    
97.         uchar A1,A2,A3,A4;
    
98.         uchar B1,B2;
    
99.            i = price/100;    //得到整数部分
    
100.            j = price - i*100;//得到小数部分
     
101. //           int2str(a,str1);
     
102.         A1=i/1000+48;
     
103.         A2=i%1000/100+48;
     
104.         A3=i%1000%100/10+48;
     
105.         A4=i%1000%100%10+48;
     
106.         B1=j/10+48;
     
107.         B2=j%10+48;
     
108.            //显示整数部分
     
109.               Lcd_Pos(0,4);
     
110.                 Lcd_Wdat(':');
     
111.                 Lcd_Wdat(A1);
     
112.                    Lcd_Wdat(A2);
     
113.                 Lcd_Wdat(A3);
     
114.                 Lcd_Wdat(A4);
     
115.                 Lcd_Wdat('-');
     
116.            //显示小数点, 小数点部分
     
117.         //   int2str(j,str1);
     
118.         Lcd_Pos(0,7);
     
119.                 Lcd_Wdat(B1);
     
120.                 Lcd_Wdat(B2);
     
121. }
     
122. //显示单价，单位为元，四位整数，两位小数
     
123. void Display_Price()
     
124. {
     
125.            uint i,j;
     
126.         uchar A1,A2,A3,A4;
     
127.         uchar B1,B2;
     
128.            i = price/100;    //得到整数部分
     
129.            j = price - i*100;//得到小数部分
     
130. //           int2str(a,str1);
     
131.         A1=i/1000+48;
     
132.         A2=i%1000/100+48;
     
133.         A3=i%1000%100/10+48;
     
134.         A4=i%1000%100%10+48;
     
135.         B1=j/10+48;
     
136.         B2=j%10+48;
     
137.            //显示整数部分
     
138.            if (i>=1000)
     
139.            {
     
140.               Lcd_Pos(2,3);
     
141.                 Lcd_Wdat(A1);
     
142.                    Lcd_Wdat(A2);
     
143.                 Lcd_Wdat(A3);
     
144.                 Lcd_Wdat(A4);
     
145.            }
     
146.            else if (i>=100)
     
147.            {
     
148.               Lcd_Pos(2,3);
     
149.                 Lcd_Wdat(' ');
     
150.                    Lcd_Wdat(A2);
     
151.                 Lcd_Wdat(A3);
     
152.                 Lcd_Wdat(A4);
     
153.            }
     
154.            else if (i>=10)
     
155.            {
     
156.               Lcd_Pos(2,3);
     
157.                 Lcd_Wdat(' ');
     
158.                 Lcd_Wdat(' ');
     
159.                 Lcd_Wdat(A3);
     
160.                 Lcd_Wdat(A4);
     
161.            }
     
162.    else
     
163.    {
     
164.         Lcd_Pos(2,3);
     
165.                 Lcd_Wdat(' ');
     
166.                 Lcd_Wdat(' ');
     
167.                 Lcd_Wdat(' ');
     
168.                 Lcd_Wdat(A4);
     
169.    }
     
170.    //显示小数点, 小数点部分
     
171. //   int2str(j,str1);
     
172.    if(j<10)
     
173.    {
     
174.         Lcd_Pos(2,5);
     
175.                 Lcd_Wdat('.');
     
176.                 Lcd_Wdat('0');
     
177.                 Lcd_Wdat(B2);
     
178.                 Lcd_Wdat(' ');          
     
179.    }
     
180.    else
     
181.    {
     
182.         Lcd_Pos(2,5);
     
183.                 Lcd_Wdat('.');
     
184.                 Lcd_Wdat(B1);
     
185.                 Lcd_Wdat(B2);
     
186.                 Lcd_Wdat(' ');
     
187.    }
     
188. }
     
189. //显示重量，单位kg，两位整数，三位小数
     
190. void Display_Weight()
     
191. {
     
192.            uint i,j;
     
193.            uchar A1,A2;
     
194.            uchar B1,B2,B3;
     
195.            //weight单位是g                                          
     
196.            i = weight/1000;    //得到整数部分
     
197.            j = weight - i*1000;//得到小数部分
     
198.            A1=i/10+48;
     
199.            A2=i%10+48;
     
200.            B1=j/100+48;
     
201.            B2=j%100/10+48;
     
202.            B3=j%100%10+48;
     
203.         //   int2str(i,str1);
     
204.            if (i>=10)
     
205.            {
     
206.              
     
207.            }
     
208.            else
     
209.            {
     
210.                Lcd_Pos(1,4);
     
211.                 Lcd_Wdat(' ');
     
212.                 Lcd_Wdat(A2);
     
213.            }  
     
214.         //   int2str(j,str1);
     
215.            if (j<10)
     
216.            {
     
217.               Lcd_Pos(1,5);
     
218.                 Lcd_Wdat('.');
     
219.                 Lcd_Wdat('0');
     
220.                 Lcd_Wdat('0');
     
221.                 Lcd_Wdat(B3);
     
222.            }
     
223.            else if (j<100)
     
224.            {
     
225.               Lcd_Pos(1,5);
     
226.                 Lcd_Wdat('.');
     
227.                 Lcd_Wdat('0');
     
228.                 Lcd_Wdat(B2);
     
229.                 Lcd_Wdat(B3);
     
230.            }
     
231.            else
     
232.            {
     
233.               Lcd_Pos(1,5);
     
234.                 Lcd_Wdat('.');
     
235.                 Lcd_Wdat(B1);
     
236.                 Lcd_Wdat(B2);
     
237.                 Lcd_Wdat(B3);
     
238.            }
     
239. }
     
240. //显示总价，单位为元，四位整数，两位小数
     
241. void Display_Money()
     
242. {
     
243.            uint i,j;
     
244.            uchar A1,A2,A3,A4;
     
245.            uchar B1,B2;
     
246.            if (money>999999)         //超出显示量程
     
247.            {
     
248.               Lcd_Pos(3,3);
     
249.                 Lcd_Wdat('-');
     
250.                 Lcd_Wdat('-');
     
251.                    Lcd_Wdat('-');
     
252.                 Lcd_Wdat('-');
     
253.                 Lcd_Wdat('-');
     
254.                 Lcd_Wdat('-');
     
255.                 Lcd_Wdat('-');
     
256.               return;      
     
257.            }
     
258.            i = money/100;    //得到整数部分
     
259.            j = money - i*100;//得到小数部分
     
260.            A1=i/1000+48;
     
261.            A2=i%1000/100+48;
     
262.            A3=i%1000%100/10+48;
     
263.            A4=i%1000%100%10+48;
     
264.            B1=j/10+48;
     
265.            B2=j%10+48;
     
266.         //   int2str(i,str1);
     
267.            //显示整数部分
     
268.         if (i>=1000)
     
269.            {
     
270.               Lcd_Pos(3,3);
     
271.                 Lcd_Wdat(A1);
     
272.                    Lcd_Wdat(A2);
     
273.                 Lcd_Wdat(A3);
     
274.                 Lcd_Wdat(A4);
     
275.            }
     
276.            else if (i>=100)
     
277.            {
     
278.               Lcd_Pos(3,3);
     
279.                 Lcd_Wdat(' ');
     
280.                    Lcd_Wdat(A2);
     
281.                 Lcd_Wdat(A3);
     
282.                 Lcd_Wdat(A4);
     
283.            }
     
284.            else if (i>=10)
     
285.            {
     
286.               Lcd_Pos(3,3);
     
287.                 Lcd_Wdat(' ');
     
288.                 Lcd_Wdat(' ');
     
289.                 Lcd_Wdat(A3);
     
290.                 Lcd_Wdat(A4);
     
291.            }
     
292.            else
     
293.            {
     
294.              Lcd_Pos(3,3);
     
295.                 Lcd_Wdat(' ');
     
296.                 Lcd_Wdat(' ');
     
297.                 Lcd_Wdat(' ');
     
298.                 Lcd_Wdat(A4);
     
299.            }
     
300.            //显示小数点, 小数点部分
     
301.         //   int2str(j,str1);
     
302.            if(j<10)
     
303.            {
     
304.         Lcd_Pos(3,5);
     
305.                 Lcd_Wdat('.');
     
306.                 Lcd_Wdat('0');
     
307.                 Lcd_Wdat(B2);          
     
308.            }
     
309.            else
     
310.            {
     
311.         Lcd_Pos(3,5);
     
312.                 Lcd_Wdat('.');
     
313.                 Lcd_Wdat(B1);
     
314.                 Lcd_Wdat(B2);
     
315.            }
     
316. }
     
317. //显示总金额，单位为元，四位整数，两位小数
     
318. void Display_Allmoney()
     
319. {
     
320.            uint i,j;
     
321.            uchar A1,A2,A3,A4;
     
322.            uchar B1,B2;
     
323. //        all_money=all_money/2;
     
324.            if (all_money>999999)         //超出显示量程
     
325.            {
     
326.               Lcd_Pos(3,3);
     
327.                 Lcd_Wdat('-');
     
328.                 Lcd_Wdat('-');
     
329.                    Lcd_Wdat('-');
     
330.                 Lcd_Wdat('-');
     
331.                 Lcd_Wdat('-');
     
332.                 Lcd_Wdat('-');
     
333.                 Lcd_Wdat('-');
     
334.               return;      
     
335.            }
     
336.            i = all_money/100;    //得到整数部分
     
337.            j = all_money - i*100;//得到小数部分
     
338.            A1=i/1000+48;
     
339.            A2=i%1000/100+48;
     
340.            A3=i%1000%100/10+48;
     
341.            A4=i%1000%100%10+48;
     
342.            B1=j/10+48;
     
343.            B2=j%10+48;
     
344.         //   int2str(i,str1);
     
345.            //显示整数部分
     
346.         if (i>=1000)
     
347.            {
     
348.               Lcd_Pos(2,3);
     
349.                 Lcd_Wdat(A1);
     
350.                    Lcd_Wdat(A2);
     
351.                 Lcd_Wdat(A3);
     
352.                 Lcd_Wdat(A4);
     
353.            }
     
354.            else if (i>=100)
     
355.            {
     
356.               Lcd_Pos(2,3);
     
357.                 Lcd_Wdat(' ');
     
358.                    Lcd_Wdat(A2);
     
359.                 Lcd_Wdat(A3);
     
360.                 Lcd_Wdat(A4);
     
361.            }
     
362.            else if (i>=10)
     
363.            {
     
364.               Lcd_Pos(2,3);
     
365.                 Lcd_Wdat(' ');
     
366.                 Lcd_Wdat(' ');
     
367.                 Lcd_Wdat(A3);
     
368.                 Lcd_Wdat(A4);
     
369.            }
     
370.            else
     
371.            {
     
372.              Lcd_Pos(2,3);
     
373.                 Lcd_Wdat(' ');
     
374.                 Lcd_Wdat(' ');
     
375.                 Lcd_Wdat(' ');
     
376.                 Lcd_Wdat(A4);
     
377.            }
     
378.            //显示小数点, 小数点部分
     
379.         //   int2str(j,str1);
     
380.            if(j<10)
     
381.            {
     
382.         Lcd_Pos(2,5);
     
383.                 Lcd_Wdat('.');
     
384.                 Lcd_Wdat('0');
     
385.                 Lcd_Wdat(B2);          
     
386.            }
     
387.            else
     
388.            {
     
389.         Lcd_Pos(2,5);
     
390.                 Lcd_Wdat('.');
     
391.                 Lcd_Wdat(B1);
     
392.                 Lcd_Wdat(B2);
     
393.            }
     
394. }
     
395. //数据初始化
     
396. void Data_Init()
     
397. {
     
398.            price = 0;
     
399.            DotPos = 0;
     
400.            beep = 1;
     
401.            alert = 1;
     
402.         num_name=0;
     
403.         all_money=0;
     
404.         Dec_pi=0;
     
405.         dec_weight=0;
     
406.         all_flag=0;
     
407. }
     
408. //管脚配置
     
409. void Port_Init()
     
410. {
     
411.        
     
412. }
     
413. //定时器0初始化
     
414. void Timer0_Init()
     
415. {
     
416.         ET0 = 1;        //允许定时器0中断
     
417.         TMOD = 1;       //定时器工作方式选择
     
418.         TL0 = 0x06;     
     
419.         TH0 = 0xf8;     //定时器赋予初值
     
420.         TR0 = 1;        //启动定时器
     
421. }
     
422. //定时器0中断
     
423. void Timer0_ISR (void) interrupt 1 using 0
     
424. {
     
425.         TL0 = 0x06;
     
426.         TH0 = 0xf8;     //定时器赋予初值
     
427. 
     
428.         //每0.5秒钟刷新重量
     
429.     Counter ++;
     
430.     if (Counter >= 200)
     
431.     {
     
432.                FlagTest = 1;
     
433.                    Counter = 0;
     
434.     }
     
435. }
     
436. //按键响应程序，参数是键值
     
437. //返回键值：
     
438. //         7          8    9      10(清0)
     
439. //         4          5    6      11(删除)
     
440. //         1          2    3      12(未定义)
     
441. //         14(未定义) 0    15(.)  13(确定价格)
     
442. 
     
443. void KeyPress(uchar keycode)
     
444. {
     
445.            uint nam1,nam2;
     
446.         uchar i;
     
447.         switch (keycode)
     
448.            {
     
449.               case 0:
     
450.               case 1:
     
451.               case 2:
     
452.               case 3:
     
453.               case 4:
     
454.               case 5:
     
455.               case 6:
     
456.               case 7:
     
457.               case 8:
     
458.               case 9:
     
459.             //目前在设置整数位，要注意price是整型，存储单位为分
     
460.                    if (DotPos == 0)
     
461.                 {  
     
462.                     //最多只能设置到千位
     
463.                         if (price<100000)
     
464.                         {
     
465.                               price=price*10+keycode*100;
     
466.                         }
     
467.                 }
     
468.                  //目前在设置小数位
     
469.                 else if (DotPos==1)  //小数点后第一位
     
470.                 {
     
471.                     price=price+keycode*10;
     
472.                         DotPos++;
     
473.                 }
     
474.                 else if (DotPos==2)
     
475.                 {
     
476.                     price=price+keycode;
     
477.                         DotPos++;
     
478.                 }
     
479.                 if(num_name==0)
     
480.                 {
     
481.                         Display_Namenum();
     
482.                 }
     
483.                 else if(num_name==1)
     
484.                 {
     
485.                         Display_Price();
     
486.                 }
     
487.             break;
     
488.               case 10:   //清零键
     
489.                      To_Zero();
     
490.                          Display_Price();
     
491.                         Display_Namenum();
     
492.                          FlagSetPrice = 0;
     
493.                          DotPos = 0;
     
494.                         num_name=0;
     
495.                         Dec_pi=0;
     
496.                         dec_weight=0;
     
497.                          break;
     
498.                   case 11:        //删除键，按一次删除最右一个数字
     
499.                      if (DotPos==2)
     
500.                          {
     
501.                             price=price/10;
     
502.                                 price=price*10;
     
503.                                 DotPos--;
     
504.                          }
     
505.                          else if (DotPos==1)
     
506.                          {
     
507.                             price=price/100;
     
508.                                 price=price*100;
     
509.                                 DotPos--;
     
510.                          }
     
511.                          else if (DotPos==0)
     
512.                          {
     
513.                             price=price/1000;
     
514.                                 price=price*100;
     
515.                          }
     
516.                          if(num_name==0)
     
517.                         {
     
518.                                 Display_Namenum();
     
519.                         }
     
520.                         else if(num_name==1)
     
521.                         {
     
522.                                 Display_Price();
     
523.                         }
     
524.                  break;
     
525.                 case 12:                //
     
526.                         Dec_pi=1;        //去皮变量
     
527.                         break;
     
528.               case 13:   //确认键,名称数量和单价
     
529.                      if(num_name==0)
     
530.                         {
     
531.                                 nam1=price/100;
     
532.                                 nam2=price-nam1*100;
     
533.                                    num_name=1;
     
534.                                 if(nam2!=0)
     
535.                                 {
     
536.                                         //显示整数部分
     
537.                                       Lcd_Pos(0,4);
     
538.                                         Lcd_Wdat(':');
     
539.                                         Lcd_Wdat(' ');
     
540.                                         Lcd_Pos(0,5);                        //显示位置为第四行的第1个字符               
     
541.                                         i = 0;
     
542.                                         if(nam1==1)
     
543.                                         {
     
544.                                             while(name1[i] != '\0')
     
545.                                             {
     
546.                                                        Lcd_Wdat(name1[i]);             //显示相应表格中的字符                  
     
547.                                                        i++;
     
548.                                             }
     
549.                                         }
     
550.                                         else if(nam1==2)
     
551.                                         {
     
552.                                             while(name2[i] != '\0')
     
553.                                             {
     
554.                                                        Lcd_Wdat(name2[i]);             //显示相应表格中的字符                  
     
555.                                                        i++;
     
556.                                             }       
     
557.                                         }
     
558.                                         else if(nam1==3)
     
559.                                         {
     
560.                                             while(name3[i] != '\0')
     
561.                                             {
     
562.                                                        Lcd_Wdat(name3[i]);             //显示相应表格中的字符                  
     
563.                                                        i++;
     
564.                                             }       
     
565.                                         }
     
566.                                            else if(nam1==4)
     
567.                                         {
     
568.                                             while(name4[i] != '\0')
     
569.                                             {
     
570.                                                        Lcd_Wdat(name4[i]);             //显示相应表格中的字符                  
     
571.                                                        i++;
     
572.                                             }       
     
573.                                         }
     
574.                                         else if(nam1==5)
     
575.                                         {
     
576.                                             while(name5[i] != '\0')
     
577.                                             {
     
578.                                                        Lcd_Wdat(name5[i]);             //显示相应表格中的字符                  
     
579.                                                        i++;
     
580.                                             }       
     
581.                                         }
     
582.                                         else if(nam1==6)
     
583.                                         {       
     
584.                                             while(name6[i] != '\0')
     
585.                                             {
     
586.                                                        Lcd_Wdat(name6[i]);             //显示相应表格中的字符                  
     
587.                                                        i++;
     
588.                                             }       
     
589.                                         }
     
590.                                         else if(nam1==7)
     
591.                                         {
     
592.                                             while(name7[i] != '\0')
     
593.                                             {
     
594.                                                        Lcd_Wdat(name7[i]);             //显示相应表格中的字符                  
     
595.                                                        i++;
     
596.                                             }       
     
597.                                         }
     
598.                                            else if(nam1==8)
     
599.                                         {
     
600.                                             while(name8[i] != '\0')
     
601.                                             {
     
602.                                                        Lcd_Wdat(name8[i]);             //显示相应表格中的字符                  
     
603.                                                        i++;
     
604.                                             }       
     
605.                                         }
     
606.                                         else if(nam1==9)
     
607.                                         {
     
608.                                             while(name9[i] != '\0')
     
609.                                             {
     
610.                                                        Lcd_Wdat(name9[i]);             //显示相应表格中的字符                  
     
611.                                                        i++;
     
612.                                             }       
     
613.                                         }
     
614.                                         else if(nam1==10)
     
615.                                         {
     
616.                                             while(name10[i] != '\0')
     
617.                                             {
     
618.                                                        Lcd_Wdat(name10[i]);             //显示相应表格中的字符                  
     
619.                                                        i++;
     
620.                                             }       
     
621.                                         }
     
622.                                         else
     
623.                                         {
     
624.                                                 num_name=0;
     
625.                                                 Lcd_Pos(0,4);
     
626.                                                 Lcd_Wdat(':');
     
627.                                                 Lcd_Wdat('0');
     
628.                                                 Lcd_Wdat('0');
     
629.                                                 Lcd_Wdat('0');
     
630.                                                 Lcd_Wdat('0');
     
631.                                                 Lcd_Wdat('-');
     
632.                                                 Lcd_Wdat('0');
     
633.                                                 Lcd_Wdat('0');
     
634.                                         }
     
635.                                 }
     
636.                                 else if(nam2==0)
     
637.                                 {
     
638.                                         num_name=0;
     
639.                                         Lcd_Pos(0,4);
     
640.                                         Lcd_Wdat(':');
     
641.                                         Lcd_Wdat('0');
     
642.                                         Lcd_Wdat('0');
     
643.                                         Lcd_Wdat('0');
     
644.                                         Lcd_Wdat('0');
     
645.                                         Lcd_Wdat('-');
     
646.                                         Lcd_Wdat('0');
     
647.                                         Lcd_Wdat('0');       
     
648.                                 }
     
649.                                 shuliang=nam2;
     
650.                                 price=0;
     
651.                                 DotPos=0;
     
652.                                 Dec_pi=0;
     
653.                         }
     
654.                         else if(num_name==1)
     
655.                         {
     
656.                                 FlagSetPrice = 1;
     
657.                                  DotPos=0;
     
658.                                 num_name=0;
     
659.                                 Dec_pi=0;
     
660.                         }
     
661.                          break;
     
662.                 case 14:                 //累计
     
663.                         all_money=all_money+money;
     
664.                         break;
     
665.                   case 15:   //小数点按下
     
666.                          if (DotPos == 0)  
     
667.                          {   
     
668.                                 DotPos = 1;      //小数点后第一位
     
669.                          }
     
670.                      break;
     
671.                    }
     
672.         Delay(10);
     
673. }
     
674. void main()
     
675. {
     
676.         //   Rom_CS=1;
     
677.            Lcd_Init();
     
678.            EA = 0;
     
679.            Data_Init();
     
680.            Port_Init();
     
681.            Timer0_Init();
     
682.            //初始化完成，开中断
     
683.            EA = 1;
     
684.            beep=1;
     
685.            //背光
     
686.         //   LedA = 1;
     
687.            Lcd_Clear();    //clear all dots
     
688.           Lcd_Display1();
     
689.           Delay(1000);
     
690.           To_Zero();
     
691.         Lcd_Clear();
     
692.           Lcd_Display2();
     
693.            Display_Price();   
     
694.            while(1)
     
695.            {
     
696.               //每0.5秒称重一次
     
697.                   if (FlagTest==1)
     
698.                   {
     
699.                      //称重，得到重量值weight，单位为g
     
700.                          AdVal=ReadCount();
     
701.                          weight=FullScale-AdVal/1000;
     
702.                          if (weight>0x8000) weight=0;
     
703.                          weight=10000*weight/FullScale;
     
704.                          weight=weight*RATIO;
     
705.                        
     
706.                         if(Dec_pi==1)
     
707.                         {
     
708.                                 dec_weight=weight;
     
709.                                 Dec_pi=0;
     
710.                         }
     
711.                         weight=weight-dec_weight;
     
712.                          //如果超量程，则报警
     
713.                          if (weight >= 10000)
     
714.                          {
     
715.                             beep = 0;
     
716.                                 alert = 0;
     
717.                                 Lcd_Pos(1,4);
     
718.                                 Lcd_Wdat('-');
     
719.                                 Lcd_Wdat('-');
     
720.                                    Lcd_Wdat('-');
     
721.                                 Lcd_Wdat('-');
     
722.                                 Lcd_Wdat('-');
     
723.                                 Lcd_Wdat('-');
     
724. 
     
725.                                    Lcd_Pos(3,3);
     
726.                                 Lcd_Wdat('-');
     
727.                                 Lcd_Wdat('-');
     
728.                                    Lcd_Wdat('-');
     
729.                                 Lcd_Wdat('-');
     
730.                                 Lcd_Wdat('-');
     
731.                                 Lcd_Wdat('-');
     
732.                                 Lcd_Wdat('-');
     
733.                          }
     
734.                          //如果不超量程
     
735.                          else
     
736.                          {
     
737.                             beep = 1;
     
738.                                 alert = 1;
     
739.                                 //显示重量值
     
740.                         Display_Weight();                 
     
741.                                  //如果单价设定好了，则计算价格
     
742.                    
     
743. 
     
744. …………余下代码请下载附件…………
     

复制代码

电子秤的完整程序代码和原理图等资料下载：
HX711完整单片机程序.rar (206 KB, 下载次数: 610)

2017-3-17 09:30 上传

点击文件名下载附件
下载积分: 黑币 -5

厉害了，我的哥

感谢分享，正需要

谢谢楼主分享，学习下

看看学习一下

谢谢楼主分享，学习下

很不错

谢谢分享，多谢楼主

谢谢分享，多谢楼主

感谢分享

非常好，正需要！

感谢分享

谢谢分享

谢谢大佬

学习中

楼主很强

很厉害

感谢楼主分享，多谢多谢，

感谢楼主分享   

这个精度多少啊

楼主，不知道为什么，我用不了，管脚单片机都是和你一样的，上电之后重量那点一直显示0.000kg，不知道是不是我的HX711的问题还是怎么回事，我这个是称5KG的称

不错，真给力，赞一个

楼主，为啥我照你的接好后只显示第一屏的制作人什么的，12864不能跳转到第二屏显示重量啊

求发1014132202@qq.com

好东西，感谢楼主

如果用stm32的怎么弄呢

支持下 非常不错

很棒！很给力！

论坛真好 什么东西都能找到

支持下 非常不错

上层大哥，你proteus文件 有吗？能不能借我看下

好好学习天天向上!感谢大师们的奉献精神!

nb，学习一下，谢楼主

楼主好样的，学习了

刚好需要，多谢分享！