【开源】多功能称重器

二哲科技

1、介绍
正常的称重设备都只能计算物体的重量，输入价格计算出总价，这种设备比较单一，可能不太适合目前的多数应用场景，今天设计的一款多功能称重器他具有计价、计数和曲线功能，话不多说，我们来看一下怎么设计的。


2、硬件准备
4英寸迪文科技COF超薄智能串口屏一体化触摸液晶 DMG48480F040_01W【https://www.dwin.com.cn/product_detail_4840449.html】

迪文COF系列评估板【https://item.taobao.com/item.htm?id=658756536493】

HX711模块+5kg压力传感器套装

3、设计

首先是设计素材，我采用Adobe Illustrator软件进行设计，本次设计没有其余控件，都是采用页面形式，素材如下。

第一个是首页，有产品标题和进入按钮，首页右上角会显示传感器的数值。

之后是菜单页面，菜单页面有四个选项，计价，计数，曲线和矫正，矫正功能主要是为了矫正传感器的基数。

来看看计价功能的界面，会显示重量、单价和总价，右边是对价格的一个输入，同时还有去皮按钮，进入计价界面时，会默认去皮一次。

再来看看计数功能的界面，这个功能主要是用于计算物品的个数，根据单个物品的重量来计算整个物品的个数，可以用于串串香的数签，或者计算硬币数量等。

最后就是曲线功能的界面，曲线功能主要是为了直观查看到物品挥发过程中的重量变化，比数字更加直观，可以用于一些科学研究的场景。

矫正功能就是矫正称重器的准度，因为不同的传感器会有些许的区别，所以需要进行矫正。

计价功能主要是重量的显示，价格输入的显示和总价的显示，主要代码如下：

1. //计价页面===================
   
2. #define VALUATION_UNIT_PRICE_ADDR 0x1010
   
3. #define VALUATION_GRAM_ADDR 0x1000
   
4. #define VALUATION_TOTAL_PRICES_ADDR 0x1020
   
5. 
   
6. uint32_t valuation_decorticate = 0;   //计价去皮重量
   
7. uint32_t valuation_unit_price = 0;    //单价
   
8. 
   
9. //单价刷新
   
10. void page_valuation_unit_price_refresh()
    
11. {
    
12.     uint8_t test_display[10] = {0};
    
13.     if(valuation_unit_price < 1000)
    
14.     {
    
15.         test_display[0] = valuation_unit_price / 100 % 10 + 0x30;
    
16.         test_display[1] = '.';
    
17.         test_display[2] = valuation_unit_price / 10 % 10 + 0x30;
    
18.         test_display[3] = valuation_unit_price / 1 % 10 + 0x30;
    
19.         dgus_show_text_value_set(VALUATION_UNIT_PRICE_ADDR, test_display, 4);
    
20.     }
    
21.     else if(valuation_unit_price < 10000)
    
22.     {
    
23.         test_display[0] = valuation_unit_price / 1000 % 10 + 0x30;
    
24.         test_display[1] = valuation_unit_price / 100 % 10 + 0x30;
    
25.         test_display[2] = '.';
    
26.         test_display[3] = valuation_unit_price / 10 % 10 + 0x30;
    
27.         test_display[4] = valuation_unit_price / 1 % 10 + 0x30;
    
28.         dgus_show_text_value_set(VALUATION_UNIT_PRICE_ADDR, test_display, 4);
    
29.     }
    
30.     else if(valuation_unit_price < 100000)
    
31.     {
    
32.         test_display[0] = valuation_unit_price / 10000 % 10 + 0x30;
    
33.         test_display[1] = valuation_unit_price / 1000 % 10 + 0x30;
    
34.         test_display[2] = valuation_unit_price / 100 % 10 + 0x30;
    
35.         test_display[3] = '.';
    
36.         test_display[4] = valuation_unit_price / 10 % 10 + 0x30;
    
37.         test_display[5] = valuation_unit_price / 1 % 10 + 0x30;
    
38.         dgus_show_text_value_set(VALUATION_UNIT_PRICE_ADDR, test_display, 4);
    
39.     }
    
40.     else if(valuation_unit_price < 1000000)
    
41.     {
    
42.         test_display[0] = valuation_unit_price / 100000 % 10 + 0x30;
    
43.         test_display[1] = valuation_unit_price / 10000 % 10 + 0x30;
    
44.         test_display[2] = valuation_unit_price / 1000 % 10 + 0x30;
    
45.         test_display[3] = valuation_unit_price / 100 % 10 + 0x30;
    
46.         test_display[4] = '.';
    
47.         test_display[5] = valuation_unit_price / 10 % 10 + 0x30;
    
48.         test_display[6] = valuation_unit_price / 1 % 10 + 0x30;
    
49.         dgus_show_text_value_set(VALUATION_UNIT_PRICE_ADDR, test_display, 4);
    
50.     }
    
51. }
    
52. 
    
53. //重量刷新
    
54. void page_valuation_weight_refresh()
    
55. {
    
56.     uint8_t test_display[10] = {0x30};
    
57.     uint32_t gram_display = 0;
    
58. 
    
59.     if(gram_value >= valuation_decorticate)
    
60.     {
    
61.         gram_display = gram_value - valuation_decorticate;
    
62.         if(gram_display < 10)
    
63.         {
    
64.             test_display[0] = gram_display / 1 % 10 + 0x30;
    
65.             dgus_show_text_value_set(VALUATION_GRAM_ADDR, test_display, 3);
    
66.         }
    
67.         else if(gram_display < 100)
    
68.         {
    
69.             test_display[0] = gram_display / 10 % 10 + 0x30;
    
70.             test_display[1] = gram_display / 1 % 10 + 0x30;
    
71.             dgus_show_text_value_set(VALUATION_GRAM_ADDR, test_display, 3);
    
72.         }
    
73.         else if(gram_display < 1000)
    
74.         {
    
75.             test_display[0] = gram_display / 100 % 10 + 0x30;
    
76.             test_display[1] = gram_display / 10 % 10 + 0x30;
    
77.             test_display[2] = gram_display / 1 % 10 + 0x30;
    
78.             dgus_show_text_value_set(VALUATION_GRAM_ADDR, test_display, 3);
    
79.         }
    
80.         else if(gram_display < 10000)
    
81.         {
    
82.             test_display[0] = gram_display / 1000 % 10 + 0x30;
    
83.             test_display[1] = gram_display / 100 % 10 + 0x30;
    
84.             test_display[2] = gram_display / 10 % 10 + 0x30;
    
85.             test_display[3] = gram_display / 1 % 10 + 0x30;
    
86.             dgus_show_text_value_set(VALUATION_GRAM_ADDR, test_display, 3);
    
87.         }
    
88.         else if(gram_display < 100000)
    
89.         {
    
90.             test_display[0] = gram_display / 10000 % 10 + 0x30;
    
91.             test_display[1] = gram_display / 1000 % 10 + 0x30;
    
92.             test_display[2] = gram_display / 100 % 10 + 0x30;
    
93.             test_display[3] = gram_display / 10 % 10 + 0x30;
    
94.             test_display[4] = gram_display / 1 % 10 + 0x30;
    
95.             dgus_show_text_value_set(VALUATION_GRAM_ADDR, test_display, 3);
    
96.         }
    
97.     }
    
98.     else
    
99.     {
    
100.         dgus_show_text_value_set(VALUATION_GRAM_ADDR, test_display, 3);
     
101.     }
     
102. }
     
103. 
     
104. //总价刷新
     
105. void page_valuation_price_refresh()
     
106. {
     
107.     uint32_t price_value = 0;
     
108.     uint8_t test_display[10] = {0x30, '.', 0x30, 0x30};
     
109. 
     
110.     if(gram_value >= valuation_decorticate)
     
111.     {
     
112.         price_value = (gram_value - valuation_decorticate) * valuation_unit_price * 2 / 1000;
     
113.         if(price_value < 1000)
     
114.         {
     
115.             test_display[0] = price_value / 100 % 10 + 0x30;
     
116.             test_display[1] = '.';
     
117.             test_display[2] = price_value / 10 % 10 + 0x30;
     
118.             test_display[3] = price_value / 1 % 10 + 0x30;
     
119.             dgus_show_text_value_set(VALUATION_TOTAL_PRICES_ADDR, test_display, 4);
     
120.         }
     
121.         else if(price_value < 10000)
     
122.         {
     
123.             test_display[0] = price_value / 1000 % 10 + 0x30;
     
124.             test_display[1] = price_value / 100 % 10 + 0x30;
     
125.             test_display[2] = '.';
     
126.             test_display[3] = price_value / 10 % 10 + 0x30;
     
127.             test_display[4] = price_value / 1 % 10 + 0x30;
     
128.             dgus_show_text_value_set(VALUATION_TOTAL_PRICES_ADDR, test_display, 4);
     
129.         }
     
130.         else if(price_value < 100000)
     
131.         {
     
132.             test_display[0] = price_value / 10000 % 10 + 0x30;
     
133.             test_display[1] = price_value / 1000 % 10 + 0x30;
     
134.             test_display[2] = price_value / 100 % 10 + 0x30;
     
135.             test_display[3] = '.';
     
136.             test_display[4] = price_value / 10 % 10 + 0x30;
     
137.             test_display[5] = price_value / 1 % 10 + 0x30;
     
138.             dgus_show_text_value_set(VALUATION_TOTAL_PRICES_ADDR, test_display, 4);
     
139.         }
     
140.         else if(price_value < 1000000)
     
141.         {
     
142.             test_display[0] = price_value / 100000 % 10 + 0x30;
     
143.             test_display[1] = price_value / 10000 % 10 + 0x30;
     
144.             test_display[2] = price_value / 1000 % 10 + 0x30;
     
145.             test_display[3] = price_value / 100 % 10 + 0x30;
     
146.             test_display[4] = '.';
     
147.             test_display[5] = price_value / 10 % 10 + 0x30;
     
148.             test_display[6] = price_value / 1 % 10 + 0x30;
     
149.             dgus_show_text_value_set(VALUATION_TOTAL_PRICES_ADDR, test_display, 4);
     
150.         }
     
151.     }
     
152.     else
     
153.     {
     
154.         dgus_show_text_value_set(VALUATION_TOTAL_PRICES_ADDR, test_display, 4);
     
155.     }
     
156. 
     
157. }
     
158. 
     
159. void page_valuation_decorticate()
     
160. {
     
161.     valuation_decorticate = gram_value;
     
162.     page_valuation_weight_refresh();
     
163. }
     
164. 
     
165. void page_valuation_1()
     
166. {
     
167.     if(valuation_unit_price < 100000)
     
168.     {
     
169.         valuation_unit_price = valuation_unit_price * 10 + 1;
     
170.         page_valuation_unit_price_refresh();
     
171.     }
     
172. }
     
173. void page_valuation_2()
     
174. {
     
175.     if(valuation_unit_price < 100000)
     
176.     {
     
177.         valuation_unit_price = valuation_unit_price * 10 + 2;
     
178.         page_valuation_unit_price_refresh();
     
179.     }
     
180. }
     
181. void page_valuation_3()
     
182. {
     
183.     if(valuation_unit_price < 100000)
     
184.     {
     
185.         valuation_unit_price = valuation_unit_price * 10 + 3;
     
186.         page_valuation_unit_price_refresh();
     
187.     }
     
188. }
     
189. void page_valuation_4()
     
190. {
     
191.     if(valuation_unit_price < 100000)
     
192.     {
     
193.         valuation_unit_price = valuation_unit_price * 10 + 4;
     
194.         page_valuation_unit_price_refresh();
     
195.     }
     
196. }
     
197. void page_valuation_5()
     
198. {
     
199.     if(valuation_unit_price < 100000)
     
200.     {
     
201.         valuation_unit_price = valuation_unit_price * 10 + 5;
     
202.         page_valuation_unit_price_refresh();
     
203.     }
     
204. }
     
205. void page_valuation_6()
     
206. {
     
207.     if(valuation_unit_price < 100000)
     
208.     {
     
209.         valuation_unit_price = valuation_unit_price * 10 + 6;
     
210.         page_valuation_unit_price_refresh();
     
211.     }
     
212. }
     
213. void page_valuation_7()
     
214. {
     
215.     if(valuation_unit_price < 100000)
     
216.     {
     
217.         valuation_unit_price = valuation_unit_price * 10 + 7;
     
218.         page_valuation_unit_price_refresh();
     
219.     }
     
220. }
     
221. void page_valuation_8()
     
222. {
     
223.     if(valuation_unit_price < 100000)
     
224.     {
     
225.         valuation_unit_price = valuation_unit_price * 10 + 8;
     
226.         page_valuation_unit_price_refresh();
     
227.     }
     
228. }
     
229. void page_valuation_9()
     
230. {
     
231.     if(valuation_unit_price < 100000)
     
232.     {
     
233.         valuation_unit_price = valuation_unit_price * 10 + 9;
     
234.         page_valuation_unit_price_refresh();
     
235.     }
     
236. }
     
237. void page_valuation_0()
     
238. {
     
239.     if(valuation_unit_price < 100000)
     
240.     {
     
241.         valuation_unit_price = valuation_unit_price * 10 + 0;
     
242.         page_valuation_unit_price_refresh();
     
243.     }
     
244. }
     
245. void page_valuation_back()
     
246. {
     
247.     valuation_unit_price = valuation_unit_price / 10;
     
248.     page_valuation_unit_price_refresh();
     
249. }
     
250. void page_valuation_clear()
     
251. {
     
252.     valuation_unit_price = 0;
     
253.     page_valuation_unit_price_refresh();
     
254. }

复制代码

计数功能和计价功能类似，都需要进行数值的显示，不过不同的是需要计算物品的数量，计算物品数量的代码如下：

1. //计数页面================================
   
2. #define COUNTER_GRAM_ADDR 0x1100
   
3. #define COUNTER_CNT_ADDR 0x1110
   
4. #define COUNTER_SINGLE_GRAM_ADDR 0x1120
   
5. 
   
6. uint32_t counter_decorticate = 0;   //计价去皮重量
   
7. uint32_t counter_unit_gram = 10;    //单个重量
   
8. 
   
9. //重量刷新
   
10. void page_counter_weight_refresh()
    
11. {
    
12.     uint8_t test_display[10] = {0x30};
    
13.     uint32_t gram_display = 0;
    
14. 
    
15.     if(gram_value >= counter_decorticate)
    
16.     {
    
17.         gram_display = gram_value - counter_decorticate;
    
18.         if(gram_display < 10)
    
19.         {
    
20.             test_display[0] = gram_display / 1 % 10 + 0x30;
    
21.             dgus_show_text_value_set(COUNTER_GRAM_ADDR, test_display, 3);
    
22.         }
    
23.         else if(gram_display < 100)
    
24.         {
    
25.             test_display[0] = gram_display / 10 % 10 + 0x30;
    
26.             test_display[1] = gram_display / 1 % 10 + 0x30;
    
27.             dgus_show_text_value_set(COUNTER_GRAM_ADDR, test_display, 3);
    
28.         }
    
29.         else if(gram_display < 1000)
    
30.         {
    
31.             test_display[0] = gram_display / 100 % 10 + 0x30;
    
32.             test_display[1] = gram_display / 10 % 10 + 0x30;
    
33.             test_display[2] = gram_display / 1 % 10 + 0x30;
    
34.             dgus_show_text_value_set(COUNTER_GRAM_ADDR, test_display, 3);
    
35.         }
    
36.         else if(gram_display < 10000)
    
37.         {
    
38.             test_display[0] = gram_display / 1000 % 10 + 0x30;
    
39.             test_display[1] = gram_display / 100 % 10 + 0x30;
    
40.             test_display[2] = gram_display / 10 % 10 + 0x30;
    
41.             test_display[3] = gram_display / 1 % 10 + 0x30;
    
42.             dgus_show_text_value_set(COUNTER_GRAM_ADDR, test_display, 3);
    
43.         }
    
44.         else if(gram_display < 100000)
    
45.         {
    
46.             test_display[0] = gram_display / 10000 % 10 + 0x30;
    
47.             test_display[1] = gram_display / 1000 % 10 + 0x30;
    
48.             test_display[2] = gram_display / 100 % 10 + 0x30;
    
49.             test_display[3] = gram_display / 10 % 10 + 0x30;
    
50.             test_display[4] = gram_display / 1 % 10 + 0x30;
    
51.             dgus_show_text_value_set(COUNTER_GRAM_ADDR, test_display, 3);
    
52.         }
    
53.     }
    
54.     else
    
55.     {
    
56.         dgus_show_text_value_set(COUNTER_GRAM_ADDR, test_display, 3);
    
57.     }
    
58. }
    
59. 
    
60. //个数刷新
    
61. void page_counter_cnt_refresh()
    
62. {
    
63.     uint32_t cnt_value = 0;
    
64.     uint8_t test_display[10] = {0x30, '.', 0x30, 0x30};
    
65. 
    
66.     if(gram_value >= counter_decorticate)
    
67.     {
    
68.         cnt_value = (gram_value - counter_decorticate) * 100 / counter_unit_gram;
    
69.         if(cnt_value < 1000)
    
70.         {
    
71.             test_display[0] = cnt_value / 100 % 10 + 0x30;
    
72.             test_display[1] = '.';
    
73.             test_display[2] = cnt_value / 10 % 10 + 0x30;
    
74.             test_display[3] = cnt_value / 1 % 10 + 0x30;
    
75.             dgus_show_text_value_set(COUNTER_CNT_ADDR, test_display, 4);
    
76.         }
    
77.         else if(cnt_value < 10000)
    
78.         {
    
79.             test_display[0] = cnt_value / 1000 % 10 + 0x30;
    
80.             test_display[1] = cnt_value / 100 % 10 + 0x30;
    
81.             test_display[2] = '.';
    
82.             test_display[3] = cnt_value / 10 % 10 + 0x30;
    
83.             test_display[4] = cnt_value / 1 % 10 + 0x30;
    
84.             dgus_show_text_value_set(COUNTER_CNT_ADDR, test_display, 4);
    
85.         }
    
86.         else if(cnt_value < 100000)
    
87.         {
    
88.             test_display[0] = cnt_value / 10000 % 10 + 0x30;
    
89.             test_display[1] = cnt_value / 1000 % 10 + 0x30;
    
90.             test_display[2] = cnt_value / 100 % 10 + 0x30;
    
91.             test_display[3] = '.';
    
92.             test_display[4] = cnt_value / 10 % 10 + 0x30;
    
93.             test_display[5] = cnt_value / 1 % 10 + 0x30;
    
94.             dgus_show_text_value_set(COUNTER_CNT_ADDR, test_display, 4);
    
95.         }
    
96.         else if(cnt_value < 1000000)
    
97.         {
    
98.             test_display[0] = cnt_value / 100000 % 10 + 0x30;
    
99.             test_display[1] = cnt_value / 10000 % 10 + 0x30;
    
100.             test_display[2] = cnt_value / 1000 % 10 + 0x30;
     
101.             test_display[3] = cnt_value / 100 % 10 + 0x30;
     
102.             test_display[4] = '.';
     
103.             test_display[5] = cnt_value / 10 % 10 + 0x30;
     
104.             test_display[6] = cnt_value / 1 % 10 + 0x30;
     
105.             dgus_show_text_value_set(COUNTER_CNT_ADDR, test_display, 4);
     
106.         }
     
107.     }
     
108.     else
     
109.     {
     
110.         dgus_show_text_value_set(COUNTER_CNT_ADDR, test_display, 4);
     
111.     }
     
112. 
     
113. }
     
114. 
     
115. //单个克数刷新
     
116. void page_counter_single_gram_refresh()
     
117. {
     
118.     uint8_t test_display[10] = {0x30};
     
119. 
     
120.     if(counter_unit_gram < 10)
     
121.     {
     
122.         test_display[0] = counter_unit_gram / 1 % 10 + 0x30;
     
123.         dgus_show_text_value_set(COUNTER_SINGLE_GRAM_ADDR, test_display, 2);
     
124.     }
     
125.     else if(counter_unit_gram < 100)
     
126.     {
     
127.         test_display[0] = counter_unit_gram / 10 % 10 + 0x30;
     
128.         test_display[1] = counter_unit_gram / 1 % 10 + 0x30;
     
129.         dgus_show_text_value_set(COUNTER_SINGLE_GRAM_ADDR, test_display, 2);
     
130.     }
     
131.     else if(counter_unit_gram < 1000)
     
132.     {
     
133.         test_display[0] = counter_unit_gram / 100 % 10 + 0x30;
     
134.         test_display[1] = counter_unit_gram / 10 % 10 + 0x30;
     
135.         test_display[2] = counter_unit_gram / 1 % 10 + 0x30;
     
136.         dgus_show_text_value_set(COUNTER_SINGLE_GRAM_ADDR, test_display, 2);
     
137.     }
     
138.     else if(counter_unit_gram < 10000)
     
139.     {
     
140.         test_display[0] = counter_unit_gram / 1000 % 10 + 0x30;
     
141.         test_display[1] = counter_unit_gram / 100 % 10 + 0x30;
     
142.         test_display[2] = counter_unit_gram / 10 % 10 + 0x30;
     
143.         test_display[3] = counter_unit_gram / 1 % 10 + 0x30;
     
144.         dgus_show_text_value_set(COUNTER_SINGLE_GRAM_ADDR, test_display, 2);
     
145.     }
     
146. }
     
147. 
     
148. //去皮
     
149. void page_counter_decorticate()
     
150. {
     
151.     counter_decorticate = gram_value;
     
152.     page_counter_weight_refresh();
     
153. }
     
154. 
     
155. void page_counter_gram_dec()
     
156. {
     
157.     if(counter_unit_gram > 1)
     
158.     {
     
159.         counter_unit_gram--;
     
160.         page_counter_single_gram_refresh();
     
161.     }
     
162. }
     
163. void page_counter_gram_add()
     
164. {
     
165.     if(counter_unit_gram < 10000)
     
166.     {
     
167.         counter_unit_gram++;
     
168.         page_counter_single_gram_refresh();
     
169.     }
     
170. }
     

复制代码

4、总结

这个项目让称重器的功能不再单一，可以根据使用场景进行功能切换，如果配合上国标的称重仪器，可以让产品更加正规完善。