欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 單片機電子秤Proteus仿真設計 附源碼與說明 [打印本頁]

---

作者: stefan99    時間: 2018-11-19 11:26
標題: 單片機電子秤Proteus仿真設計 附源碼與說明
電子秤使用說明：
按鍵：
數字鍵0-9、RTP為去皮鍵，GOOD1-GOOD4鍵為商品1-4鍵，DOLLAR為美元匯率鍵，EURO為歐元匯率鍵，UNITS為單位切換鍵，TOTAL鍵為計價鍵，ALL鍵為求和鍵，MEMO為存儲鍵，SET鍵為設置鍵，BACK鍵為萬能返回鍵，OPEN鍵為串口通訊開放鍵，CLOSE鍵為串口通信關閉鍵，SHIFT鍵為切換鍵（用來切換一個按鍵的第二功能，如數字7鍵，按下shift鍵后，數字7鍵實現為GOO1鍵的功能）
功能及使用方法：
1，計價：直接按下數字鍵，可設置0-100內的單價，可精確至小數點后一位，輸入好單價后，按下TOTAL鍵即可算出價格。
2，快速計價：首先是給商品鍵設置單價，按下SET鍵，再按下數字鍵來輸入我們想設置的單價，再按下SHIFT鍵，再按下數字鍵7即我們將想要的單價設置存儲至商品鍵1中，按下BACK鍵和SHIFT鍵返回至初始界面，接下來是快速計價，按下SHIFT鍵，再按下數字鍵7即顯示出設置好的商品鍵1的單價，最后按下計價鍵（需要再按下SHIFT鍵，否則顯示為求和功能），完成計價
3，匯率轉換：首先是設置匯率，與之前設置單價的步驟一致，按下SET鍵，再按下數字鍵來輸入我們想設置的匯率（可精確至小數點后兩位），再按下SHIFT鍵，再按下數字鍵1即我們將想要的匯率設置存儲至美元鍵中，接下來是匯率轉換，當計算完一次價格后，按下SHIFT鍵，再按下數字鍵1，既可以將價格進行所設置的匯率轉換
4，存儲求和：計算完一次價格后，按下SHIFT鍵，再按下小數點鍵即將此次價格存儲下來，可以存儲多次價格將其求和，最后按下求和鍵（即SHIFT加上計價鍵）可以將存儲的價格求和出來。
5，串口通信：按下OPEN鍵（即SHIFT加數字鍵5）既可以將計算完的價格傳至從機中在從機中顯示并記錄下來，傳送完畢后按下CLOSE鍵即可關閉通信，從機可以瀏覽最近三次的傳送價格記錄，從機中的OPEN為打開記錄，CLOSE為關閉記錄，SWITCH為切換下一條記錄。
電子秤還具有其他的小功能如去皮，單位切換等，由于操作比較直觀所以不做介紹。
設計還不夠完善，不過應付小的課程設計和要求不是很嚴格的本科畢業設計差不多夠了。

仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


單片機源程序如下:

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #include <absacc.h>
   
4. #include <math.h>
   
5. 
   
6. #define uchar unsigned char
   
7. #define uint   unsigned int
   
8. #define BUSY  0x80                              
   
9. #define DATAPORT P0
   
10. #define OP_READ 0xa1  
    
11. #define OP_WRITE 0xa0
    
12. 
    
13. sbit ADCS =P3^5;
    
14. sbit ADDI =P3^7;  
    
15. sbit ADDO =P3^7;  
    
16. sbit ADCLK =P3^6;  
    
17. sbit beep=P2^7;
    
18. sbit LCM_RS=P2^0;
    
19. sbit LCM_RW=P2^1;
    
20. sbit LCM_EN=P2^2;
    
21. sbit SCL=P2^3;
    
22. sbit SDA=P2^4;
    
23. sbit Kai=P2^5;
    
24. 
    
25. uint h1,n1,w1,g1,j1,j2,j3,j4,j5,j6,temp1,temp2,temp3,temp4=0,temp5,temp6,a3,b3,c3,d3,a4,b4,c4,d4,a7,b7,c7,d7,e7,a8,b8,c8,d8,e8;
    
26. uchar ad_data,k,n,m,e,num,s,shift,sett,h,ncm,a1,b1,c1,d1,a2,b2,c2,d2,x1,y1,z1,mc,na,nb,nc;                                                     
    
27.                   
    
28. char press_data;                                                         
    
29. unsigned char press_ge=0;                        
    
30. unsigned char press_shifen=0;                        
    
31. unsigned char press_baifen=0;                        
    
32. unsigned char press_qianfen=0;
    
33. unsigned char press_ge1=0;                        
    
34. unsigned char press_shifen1=0;                        
    
35. unsigned char press_baifen1=0;                        
    
36. unsigned char press_qianfen1=0;                        
    
37. unsigned char press_wanfen1=0;
    
38. 
    
39. uchar code str0[]={"Weight:  .   Kg "};
    
40. uchar code str1[]={"error"};
    
41. uchar code str2[]={"Price:          "};
    
42. uchar code str3[]={"Total:             "};
    
43. uchar code table2[]={0x37,0x38,0x39,0xfd,0x34,0x35,0x36,0x78,0x31,0x32,0x33,0x2d,0x3d,0x30,0x2e,};
    
44. uchar code str4[]={"Weight:    .  g "};
    
45. uchar code str5[]={"GOOD :          "};
    
46. uchar code str6[]={"RATE :          "};
    
47. uchar code str7[]={"DOLLAR:         "};  
    
48. uchar code str8[]={"EURO  :         "};   
    
49. void delay(uint);
    
50. void lcd_wait(void);
    
51. void delay_LCM(uint);                                                                                                     
    
52. void initLCM( void);                                                                                                      
    
53. void lcd_wait(void);                                                                                                      
    
54. void WriteCommandLCM(uchar WCLCM,uchar BusyC);                              
    
55. void WriteDataLCM(uchar WDLCM);                                             
    
56. void DisplayOneChar(uchar X,uchar Y,uchar DData);                           
    
57. void DisplayListChar(uchar X,uchar Y,uchar code *DData);                                                
    
58. void display(void);
    
59. uchar Adc0832(unsigned char channel);                                                                                                                        
    
60. void data_pro(void);
    
61. void data_pro1(void);
    
62. void display1(void);
    
63. void alarm(void);
    
64. void weishu1(uint m);
    
65. void WriteSet(uchar X,uchar Y);
    
66. uchar ReadSet(uchar channel);
    
67. void com(uchar X);
    
68. void intcom(void);
    
69. 
    
70. void main(void)
    
71. {
    
72.     delay(500);                                            
    
73.            initLCM( );
    
74.         intcom();
    
75.         delay(100);  
    
76.            WriteCommandLCM(0x01,1);                    
    
77.     DisplayListChar(0,0,str0);
    
78.         DisplayListChar(0,1,str2);
    
79.         while(1)
    
80.     {
    
81.            if(ncm!=1)
    
82.            {
    
83.            ad_data =Adc0832(0);
    
84.            h=ad_data;   
    
85.            alarm();
    
86.            data_pro();
    
87.            display();
    
88.            }
    
89. if(ncm==1)
    
90. {
    
91.    ad_data=Adc0832(0)-h;
    
92.    alarm();
    
93.    data_pro();
    
94.         display();
    
95. }
    
96.          if(k==1&&(shift%2)==0)
    
97.      {
    
98. 
    
99.       DisplayOneChar((s+7),1,table2[num-1]);
    
100.           if(s+7==8) x1=n;
     
101.           if(s+7==9) y1=n;
     
102.           if(s+7==11) z1=n;
     
103.           if(s+7==12) g1=n;
     
104.           mc=10*x1+y1;
     
105.      }
     
106.         if(num==1&&(shift%2)==1&&(sett%2)==1)
     
107.         {
     
108.          WriteCommandLCM(0x01,1);
     
109.          DisplayListChar(0,1,str5);
     
110.          DisplayOneChar(4,1,table2[8]);
     
111.          a1=mc;b1=z1;c1=x1;d1=y1;
     
112.          DisplayOneChar(8,1,x1+0x30);
     
113.          DisplayOneChar(9,1,y1+0x30);
     
114.          DisplayOneChar(10,1,0x2e);
     
115.           DisplayOneChar(11,1,z1+0x30);
     
116.      WriteSet(0x01,mc);
     
117.          WriteSet(0x02,x1);
     
118.      WriteSet(0x03,y1);
     
119.      WriteSet(0x04,z1);
     
120.         }
     
121.    if(num==1&&(shift%2)==1&&(sett%2)==0&&k!='=')
     
122.    {        
     
123.         WriteCommandLCM(0x01,1);
     
124.         DisplayListChar(0,1,str2);
     
125.         a1=ReadSet(0x01);
     
126.         c1=ReadSet(0x02);
     
127.         DisplayOneChar(8,1,c1+0x30);
     
128.         d1=ReadSet(0x03);
     
129.         DisplayOneChar(9,1,d1+0x30);
     
130.         DisplayOneChar(10,1,0x2e);
     
131.         b1=ReadSet(0x04);
     
132.         DisplayOneChar(11,1,b1+0x30);
     
133.          mc=a1;z1=b1;
     
134.    }
     
135.         if(num==2&&(shift%2)==1&&(sett%2)==1)
     
136.         {
     
137.          WriteCommandLCM(0x01,1);
     
138.          DisplayListChar(0,1,str5);
     
139.          DisplayOneChar(4,1,table2[9]);
     
140.          a2=mc;b2=z1;c2=x1;d2=y1;
     
141.          DisplayOneChar(8,1,x1+0x30);
     
142.          DisplayOneChar(9,1,y1+0x30);
     
143.          DisplayOneChar(10,1,0x2e);
     
144.          DisplayOneChar(11,1,z1+0x30);
     
145. WriteSet(0x05,mc);
     
146. WriteSet(0x06,z1);
     
147. WriteSet(0x07,x1);
     
148. WriteSet(0x08,y1);
     
149.            }
     
150.    if(num==2&&(shift%2)==1&&(sett%2)==0&&k!='=')
     
151.    {
     
152.     a2=ReadSet(0x05);
     
153.         b2=ReadSet(0x06);
     
154.     c2=ReadSet(0x07);
     
155.     d2=ReadSet(0x08);        
     
156.         WriteCommandLCM(0x01,1);
     
157.         DisplayListChar(0,1,str2);
     
158.         DisplayOneChar(8,1,c2+0x30);
     
159.         DisplayOneChar(9,1,d2+0x30);
     
160.         DisplayOneChar(10,1,0x2e);
     
161.         DisplayOneChar(11,1,b2+0x30);
     
162.          mc=a2;z1=b2;
     
163.    }
     
164.          if(num==3&&(shift%2)==1&&(sett%2)==1)
     
165.         {
     
166.          WriteCommandLCM(0x01,1);
     
167.          DisplayListChar(0,1,str5);
     
168.          DisplayOneChar(4,1,table2[10]);
     
169.          a3=mc;b3=z1;c3=x1;d3=y1;
     
170.          DisplayOneChar(8,1,x1+0x30);
     
171.          DisplayOneChar(9,1,y1+0x30);
     
172.          DisplayOneChar(10,1,0x2e);
     
173.           DisplayOneChar(11,1,z1+0x30);
     
174.         WriteSet(0x09,mc);
     
175. WriteSet(0x0a,z1);
     
176. WriteSet(0x0b,x1);
     
177. WriteSet(0x0c,y1);
     
178.         }
     
179.    if(num==3&&(shift%2)==1&&(sett%2)==0&&k!='=')
     
180.    {
     
181.      a3=ReadSet(0x09);
     
182.         b3=ReadSet(0x0a);
     
183.     c3=ReadSet(0x0b);
     
184.     d3=ReadSet(0x0c);
     
185.         WriteCommandLCM(0x01,1);
     
186.         DisplayListChar(0,1,str2);
     
187.         DisplayOneChar(8,1,c3+0x30);
     
188.         DisplayOneChar(9,1,d3+0x30);
     
189.         DisplayOneChar(10,1,0x2e);
     
190.         DisplayOneChar(11,1,b3+0x30);
     
191.          mc=a3;z1=b3;
     
192.    }
     
193.         if(num==5&&(shift%2)==1&&(sett%2)==1)
     
194.         {
     
195.          WriteCommandLCM(0x01,1);
     
196.          DisplayListChar(0,1,str5);
     
197.          DisplayOneChar(4,1,table2[4]);
     
198.          a4=mc;b4=z1;c4=x1;d4=y1;
     
199.          DisplayOneChar(8,1,x1+0x30);
     
200.          DisplayOneChar(9,1,y1+0x30);
     
201.          DisplayOneChar(10,1,0x2e);
     
202.           DisplayOneChar(11,1,z1+0x30);
     
203.         }
     
204.    if(num==5&&(shift%2)==1&&(sett%2)==0&&k!='=')
     
205.    {
     
206.         WriteCommandLCM(0x01,1);
     
207.         DisplayListChar(0,1,str2);
     
208.         DisplayOneChar(8,1,c4+0x30);
     
209.         DisplayOneChar(9,1,d4+0x30);
     
210.         DisplayOneChar(10,1,0x2e);
     
211.         DisplayOneChar(11,1,b4+0x30);
     
212.          mc=a4;z1=b4;
     
213.    }
     
214.    if(num==6&&(shift%2)==1)
     
215.    {
     
216.         ES=1;
     
217.         com(na);
     
218.         delay(10);
     
219.         com(nb);
     
220.         delay(10);
     
221.         com(nc);
     
222.   num=0;
     
223.    }
     
224.    if(num==7&&(shift%2)==1)
     
225.    {
     
226.    ES=0;
     
227.    }
     
228.    if(num==9&&(shift%2)==1&&(sett%2)==1)
     
229.         {
     
230.          WriteCommandLCM(0x01,1);
     
231.          DisplayListChar(0,1,str6);
     
232.          a7=mc;b7=z1;c7=x1;d7=y1;e7=g1;
     
233.          DisplayOneChar(8,1,c7+0x30);
     
234.          DisplayOneChar(9,1,d7+0x30);
     
235.          DisplayOneChar(10,1,0x2e);
     
236.          DisplayOneChar(11,1,b7+0x30);
     
237.          DisplayOneChar(12,1,e7+0x30);
     
238.                 WriteSet(0x10,mc);
     
239. WriteSet(0x11,z1);
     
240. WriteSet(0x12,x1);
     
241. WriteSet(0x13,y1);
     
242. WriteSet(0x14,g1);
     
243.         }
     
244. if(num==9&&(shift%2)==1&&(sett%2)==0)
     
245. {
     
246.   b7=ReadSet(0x11);
     
247.   c7=ReadSet(0x12);
     
248.   d7=ReadSet(0x13);
     
249.   e7=ReadSet(0x14);
     
250.    j1=w1/100;j2=w1%100;j3=a7*j1*100;j4=b7*10+e7;j5=j1*j4;j6=j2*a7;j3=j3+j5+j6+(j2*j4)/100;;
     
251.    WriteCommandLCM(0x01,1);
     
252.    DisplayListChar(0,1,str7);
     
253.    weishu1(j3);
     
254.    j1=0;j2=0;j3=0;j4=0;j5=0;j6=0; num=0;
     
255. }
     
256.     if(num==10&&(shift%2)==1&&(sett%2)==1)
     
257.         {
     
258.          WriteCommandLCM(0x01,1);
     
259.          DisplayListChar(0,1,str6);
     
260.          a8=w1;b8=z1;c8=x1;d8=y1;e8=g1;
     
261.          DisplayOneChar(8,1,c8+0x30);
     
262.          DisplayOneChar(9,1,d8+0x30);
     
263.          DisplayOneChar(10,1,0x2e);
     
264.          DisplayOneChar(11,1,b8+0x30);
     
265.          DisplayOneChar(12,1,e8+0x30);
     
266.         }
     
267. if(num==10&&(shift%2)==1&&(sett%2)==0)
     
268. {
     
269.    j1=w1/100;j2=w1%100;j3=a8*j1*100;j4=b8*10+e8;j5=j1*j4;j6=j2*a8;j3=j3+j5+j6+(j2*j4)/100;
     
270.    WriteCommandLCM(0x01,1);
     
271.    DisplayListChar(0,1,str8);
     
272.    weishu1(j3);
     
273.    j1=0;j2=0;j3=0;j4=0;j5=0;j6=0; num=0;
     
274. }
     
275.         if(k=='='&&(shift%2)==0)
     
276.         {         
     
277.                 w1=mc;
     
278.                 n1=w1*temp5;
     
279.             w1=w1*temp2;
     
280.                 h1=(z1*temp1)/10;
     
281.             h1=(n1+h1)/10;
     
282.                 w1=w1+h1;
     
283.             WriteCommandLCM(0x01,1);
     
284.         DisplayListChar(0,1,str3);
     
285.                 s=0;
     
286.             weishu1(w1);
     
287.             k=0;
     
288.                 na=w1/1000;
     
289.                 nb=(w1-na*1000)/10;
     
290.                 nc=(w1-na*1000-nb*10);
     
291.         }
     
292.         if(k==' ')
     
293.         {
     
294.            WriteCommandLCM(0x80+0x40,1);
     
295.            WriteCommandLCM(0x01,1);
     
296.            DisplayListChar(0,0,str0);
     
297.            DisplayListChar(0,1,str2);
     
298.            w1=0;
     
299.            s=0;
     
300.            n1=0;
     
301.            h1=0;
     
302.            z1=0;
     
303.            x1=0;
     
304.            y1=0;
     
305.            g1=0;
     
306.            mc=0;
     
307.            sett=0;
     
308.            num=0;
     
309.            ncm=0;   //防止清零時指針后移動
     
310.         }
     
311.     if(num==15&&(shift%2)==1)
     
312.    {
     
313.          temp6=w1;
     
314.          temp4=temp4+temp6;
     
315.          k=0;
     
316.          num=0;
     
317.         }
     
318.         if(k=='='&&(shift%2)==1)
     
319.         {
     
320.         DisplayListChar(0,1,str3);
     
321.         weishu1(temp4);
     
322.         delay(2000);
     
323.         temp4=0;
     
324.         k=0;
     
325.         }
     
326.         while(num==14&&(shift%2)==1)
     
327.         {
     
328.          _nop_();                                     //空指令
     
329.         _nop_();                                   //空指令
     
330.    _nop_();                                           //空指令
     
331.    _nop_();                                           //空指令
     
332.    _nop_();                                           //空指令
     
333.    _nop_();                                           //空指令
     
334.         }
     
335.         if(num==11&&(shift%2)==1)
     
336.         {
     
337.            data_pro1();
     
338.           display1();
     
339.           delay(3000);
     
340.           k=0;
     
341.           s=0;
     
342.           num=0;
     
343.         }
     
344.   }                                                                                                
     
345. }
     
346. 
     
347. void com(uchar c)
     
348. {
     
349.   SBUF=c;
     
350.   TI=0;         
     
351.   }
     
352. void delay(uint k)
     
353. {
     
354.    uint i,j;
     
355.    for(i=0;i<k;i++)
     
356.     for(j=0;j<100;j++);
     
357. }   
     
358. 
     
359. /***********寫指令至lcm*************/
     
360. void WriteCommandLCM(uchar WCLCM,uchar BusyC)
     
361. {
     
362.     if(BusyC)                                   //判別busyC是否非零
     
363.         lcd_wait();                                   //非零執行檢測忙信號
     
364.         DATAPORT=WCLCM;                           //將WCLCM的值賦予P0口
     
365.     LCM_RS=0;                  //選擇指令寄存器
     
366.     LCM_RW=0;                 //選擇寫模式        
     
367.     LCM_EN=1;                              //EN高電平，讀取信息
     
368.         _nop_();                                     //空指令
     
369.         _nop_();                                   //空指令
     
370.    _nop_();                                           //空指令
     
371.    _nop_();                                           //空指令
     
372.    _nop_();                                           //空指令
     
373.    _nop_();                                           //空指令
     
374.    _nop_();                                           //空指令
     
375.     LCM_EN=0;                                //EN負跳變，執行指令
     
376.    
     
377. }
     
378. 
     
379. /***********寫數據至lcm*************/
     
380. void WriteDataLCM(uchar WDLCM)
     
381. {
     
382.     lcd_wait( );              //檢測忙信號   
     
383.         DATAPORT=WDLCM;                          //將WDLCM的值賦予P0口
     
384.     LCM_RS=1;                 //選擇數據寄存器
     
385.     LCM_RW=0;                     //選擇寫模式
     
386.     LCM_EN=1;                                  //EN高電平，讀取信息
     
387.     _nop_();                                  //空指令
     
388.            _nop_();                                  //空指令
     
389.            _nop_();                                  //空指令
     
390.            _nop_();                                  //空指令
     
391.            _nop_();                                  //空指令
     
392.            _nop_();                                  //空指令
     
393.            _nop_();                                  //空指令
     
394.         _nop_();                                  //空指令
     
395.     LCM_EN=0;                                 //EN負跳變，執行指令
     
396. }
     
397. /***********lcm內部等待函數*************/
     
398. 
     
399. void lcd_wait(void)
     
400. {
     
401.     DATAPORT=0xff;                      //令P0口等于0ffh
     
402.         LCM_EN=1;                                 //EN高電平，讀取信息
     
403.     LCM_RS=0;                           
     
404.     LCM_RW=1;                            //rs=0,rw=1,讀忙標志和地址
     
405.     _nop_();                                 //空指令
     
406.     _nop_();                                 //空指令
     
407.     _nop_();                                 //空指令
     
408.     _nop_();                                 //空指令
     
409.     _nop_();                                 //空指令
     
410.     _nop_();                                 //空指令
     
411.         _nop_();                                 //空指令
     
412.     while(DATAPORT&BUSY)           //若讀忙標志位為1,則執行while循環
     
413.         {  LCM_EN=0;                         //EN低電平，執行指令，標志位可變
     
414.            _nop_();                                 //空指令
     
415.     _nop_();                                 //空指令
     
416.     _nop_();                                 //空指令
     
417.     _nop_();                                 //空指令
     
418.     _nop_();                                 //空指令
     
419.     _nop_();                                 //空指令
     
420.     _nop_();                                  //空指令
     
421.     _nop_();                                 //空指令
     
422.            LCM_EN=1;                         //EN高電平，讀取信息
     
423.     _nop_();
     
424.     _nop_();
     
425.     _nop_();
     
426.     _nop_();
     
427.     _nop_();
     
428.         _nop_();
     
429.         _nop_();
     
430.            }         
     
431.            LCM_EN=0;                                //EN低電平，執行指令
     
432. }
     
433. 
     
434. /**********LCM初始化子函數***********/
     
435. 
     
436. void initLCM( )
     
437. {  
     
438.     LCM_EN=0;
     
439.         DATAPORT=0;        
     
440.         delay(15);
     
441.         WriteCommandLCM(0x38,0);    //8bit數據傳送，2行顯示，5*7字型，不檢測忙信號
     
442.     delay(5);                                         //延時5ms
     
443.     WriteCommandLCM(0x38,0);        //8bit數據傳送，2行顯示，5*7字型，不檢測忙信號
     
444.     delay(5);                                         //延時5ms
     
445.     WriteCommandLCM(0x38,0);        //8bit數據傳送，2行顯示，5*7字型，不檢測忙信號
     
446.     delay(5);                                         //延時5ms
     
447. 
     
448.     WriteCommandLCM(0x38,1);    //8bit數據傳送，2行顯示，5*7字型，檢測忙信號
     
449.     WriteCommandLCM(0x08,1);    //關閉顯示，檢測忙信號
     
450.     WriteCommandLCM(0x01,1);    //清屏，檢測忙信號
     
451.     WriteCommandLCM(0x06,1);    //顯示光標右移設置，檢測忙信號
     
452.     WriteCommandLCM(0x0c,1);    //顯示屏打開，光標不顯示，不閃爍，檢測忙信號
     
453.         EA=1;
     
454.         TMOD=0x21;                                        //定時器0和定時器1為操作模
     
455.         ET0=1;
     
456.         TR0=1;
     
457.         x1=0;
     
458.         y1=0;
     
459.         z1=0;
     
460. }
     
461. 
     
462. void intcom()
     
463. {
     
464. SCON=0x50;
     
465.   PCON = 0x00;
     
466. SCON = 0x40;
     
467. TH1 = 0xFd;
     
468. TL1 = 0xFd;
     
469. TR1 = 1;
     
470. ES=1;
     
471. }
     
472. /****顯示指定坐標的一個字符子函數****/
     
473. 
     
474. void DisplayOneChar(uchar X,uchar Y,uchar DData)
     
475.                                           
     
476. {
     
477.     Y&=0x01;                                  //y與01位與，即保留最后一位，其余置零
     
478.     X&=0x0f;                                 //x與0f位與，即保留低四位，其余置零
     
479.     if(Y)                                         //判斷y是否為1
     
480.         X|=0x40;                 //若y為1（顯示第二行），地址碼+0X40
     
481.     X|=0x80;                 //指令碼為地址碼+0X80
     
482.     WriteCommandLCM(X,1);         //若y為1，則顯示第二行；若y為0，則顯示第一行。
     
483.     WriteDataLCM(DData);         //寫數據至第一行或第二行中
     
484. }
     
485. 
     
486. /*******顯示指定坐標的一串字符子函數*****/
     
487. 
     
488. void DisplayListChar(uchar X,uchar Y,uchar code *DData)
     
489. {
     
490.     uchar ListLength=0;                 //定義ListLength等于0
     
491.     Y&=0x01;                                 //令y與01h位與
     
492.     X&=0x0f;                                 //令x與0fh位與
     
493.     while(X<16)                                 //若x（列數）小于16，執行while循環
     
494.     {
     
495.         DisplayOneChar(X,Y,DData[ListLength]);                 //顯示指定坐標的一個字符
     
496.         ListLength++;                                                                 //ListLength加1
     
497.         X++;                                                                                 //x（列數加1）
     
498.     }
     
499. }
     
500. 
     
501. /*******顯示程序1子函數*****/
     
502. void display(void)
     
503. {
     
504.            WriteCommandLCM(0x0c,1);                                                 //顯示屏打開，光標不顯示，不閃爍，檢測忙信號                           
     
505. if(temp1<=5000)                                                                         //若temp1(重量）小于5000g時，執行if程序
     
506. {
     
507.         DisplayListChar(0,0,str0);                                                 //顯示字符串str0
     
508.         DisplayOneChar(8,0,press_ge+0x30);                                 //在第1行第9列顯示press_ge的數值
     
509.         DisplayOneChar(10,0,press_shifen+0x30);                         //在第1行第11列顯示press_shifen的數值
     
510.         DisplayOneChar(11,0,press_baifen+0x30);                         //在第1行第12列顯示press_baifen的數值
     
511.     DisplayOneChar(12,0,press_qianfen+0x30);                 //在第1行第13列顯示press_qianfen的數值
     
512.         delay(1000);
     
513.         }
     
514. if(temp1>5000)
     
515.                 DisplayListChar(0,0,str1);
     
516. if(shift%2==1)
     
517.         DisplayOneChar(15,0,0x73);
     
518.         delay(1000);                                       
     
519. }
     
520. /*******顯示程序2子函數*****/
     
521. void display1(void)                                                               
     
522. {
     
523.            WriteCommandLCM(0x0c,1);                                                 //顯示屏打開，光標不顯示，不閃爍，檢測忙信號
     
524.         DisplayListChar(0,0,str4);                                                 //顯示字符串str4
     
525.         DisplayOneChar(7,0,press_ge1+0x30);                                 //在第1行第8列顯示press_ge1的數值
     
526.         DisplayOneChar(8,0,press_shifen1+0x30);                         //在第1行第9列顯示press_shifen1的數值
     
527.         DisplayOneChar(9,0,press_baifen1+0x30);                         //在第1行第10列顯示press_baifen1的數值
     
528.     DisplayOneChar(10,0,press_qianfen1+0x30);                 //在第1行第11列顯示press_qianfen1的數值
     
529.         DisplayOneChar(12,0,press_wanfen1+0x30);                 //在第1行第13列顯示press_wanfen1的數值
     
530.         delay(1000);                                                //延時1s
     
531. }
     
532. 
     
533. /*******讀取adc0832函數，采集并返回*****/
     
534. uchar Adc0832(unsigned char channel)   
     
535. {
     
536.     uchar i=0;                                                                                 //定義i=0
     
537.     uchar j;                                                                                 //定義j
     
538.     uint dat=0;                                                                                 //定義整數dat=0
     
539.     uchar ndat=0;                                                                         //定義ndat=0
     
540.     if(channel==0)channel=2;                                                 //如果channel=0,則channel=2
     
541.     if(channel==1)channel=3;                                                 //如果channel=1,則channel=3
     
542.     ADDI=1;                                                                                         //設置DI端為高電平
     
543.     _nop_();
     
544.     _nop_();
     
545.     ADCS=0;                                                                                         //使能端為低電平，使能端起效
     
546.     _nop_();
     
547.     _nop_();
     
548.     ADCLK=1;                                                                                 //第一個時鐘脈沖上升
     
549.     _nop_();
     
550.     _nop_();
     
551.     ADCLK=0;                                                                                 //第一個時鐘脈沖下降
     
552.     _nop_();
     
553.     _nop_();
     
554.         ADDI=0;                                                                                   //DI輸出第一個數字為0
     
555.     ADCLK=1;                                                                                 //第二個時鐘脈沖上升
     
556.     _nop_();
     
557.     _nop_();
     
558.     ADCLK=0;                                                                                 //第二個時鐘脈沖下降
     
559.     _nop_();
     
560.     _nop_();
     
561.         ADDI=0;                                                                                         //DI輸出第二個數字為0，即為以CH0為正，CH1為負的差分輸入
     
562.     ADCLK=1;                                                                                 //第三個時鐘脈沖上升
     
563.     _nop_();
     
564.     _nop_();
     
565.     ADCLK=0;                                                                                 //第三個時鐘脈沖下降
     
566.         ADDI=1;
     
567.     _nop_();
     
568.     _nop_();
     
569.     dat=0;                                                                                         
     
570.     for(i=0;i<8;i++)                                                                 //for循環八次，DI以D7至D0的順序向dat賦值
     
571.     {                                                                                                
     
572.                 dat|=ADDO;                                                                         //dat與D0輸出的值進行位或，即向dat輸值                                                        
     
573.         ADCLK=1;
     
574.                 _nop_();
     
575.         _nop_();
     
576.                 ADCLK=0;                                                                         //時鐘脈沖下降
     
577.         _nop_();
     
578.         _nop_();
     
579.                 dat<<=1;
     
580.         if(i==7)dat|=ADDO;                                                                                                                                 
     
581.     }  
     
582.     for(i=0;i<8;i++)                                                                 //for循環八次，DI以D0至D7的順序向ndat賦值
     
583.     {
     
584.         j=0;                                                                                 //令j=0
     
585.         j=j|ADDO;                                                                         //j與D0輸出的值進行位或，即向j輸值
     
586.         ADCLK=1;                                                                         //時鐘脈沖上升
     
587.         _nop_();
     
588.         _nop_();
     
589.         ADCLK=0;                                                                         //時鐘脈沖下降
     
590.         _nop_();
     
591.         _nop_();
     
592.         j=j<<7;                                                                                 //將j的值左移7位
     
593.         ndat=ndat|j;                                                                 //將ndat與j的值位或并將結果賦予nadt中,即將j值輸出到ndat上
     
594.         if(i<7)ndat>>=1;                                                         //此步驟和以上步驟實則將ndat的值變成以D7至D0的順序
     
595.     }
     
596.     ADCS=1;                                                                                         //CS端失效
     
597.     ADCLK=0;
     
598.         ADDO=1;        
     
599. if(dat==ndat)                                                                                         //DO端高電平
     
600.         return(dat);                     
     
601. }
     
602. 
     
603. 
     
604. void data_pro(void)
     
605. {
     
606.       unsigned int;
     
607.       float  press;                             
     
608. 
     
609.           if(0<ad_data<256)                                      
     
610.                  {                           
     
611.                     int vary=ad_data;                                                                        
     
612.                         press=(0.021111*vary);                          
     
613.                         temp1=(int)(press*1000);
     
614.                         temp2=(int)(press*100);
     
615.                         temp5=temp1-10*temp2;                                                
     
616.                         press_ge=temp1/1000;                                    
     
617.                         press_shifen=(temp1%1000)/100;                           
     
618.                         press_baifen=((temp1%1000)%100)/10;                    
     
619.                         press_qianfen=((temp1%1000)%100)%10;                        
     
620. 
     
621.                       }            
     
622. }
     
623. void data_pro1(void)
     
624. {
     
625.       unsigned int;
     
626.       float  press1;                             
     
627. 
     
628.           if(0<ad_data<256)                                      
     
629.                  {                           
     
630.                     int vary=ad_data;                                                                        
     
631.                         press1=(0.021111*vary);                          
     
632.                         temp3=(int)(press1*10000);                                                        
     
633.                         press_ge1=temp3/10000;                                    
     
634.                         press_shifen1=(temp3%10000)/1000;                           
     
635.                         press_baifen1=((temp3%10000)%1000)/100;                    
     
636.                         press_qianfen1=(((temp3%10000)%1000)%100)/10;               
     
637.                         press_wanfen1=(((temp3%10000)%1000)%100)%10;
     
638.                       }            
     
639. }
     
640.   void alarm(void)
     
641. {
     
642.          if(temp1>=5000)                        
     
643. 
     
644.            beep=0;         
     
645.         
     
646.           else
     
647.               { beep=1;
     
648.                    DisplayListChar(0,0,str1);
     
649.                    }                  
     
650. }
     
651. void weishu1(uint m)
     
652. {  
     
653.    uchar wei4,wei3,wei2,wei1,wei0;
     
654.    wei4=m/10000;
     
655.    wei3=(m%10000)/1000;
     
656.    wei2=((m%10000)%1000)/100;
     
657.    wei1=(((m%10000)%1000)%100)/10;
     
658.    wei0=(((m%10000)%1000)%100)%10;
     
659.    DisplayOneChar(8,1,0x30+wei4);
     
660.    DisplayOneChar(9,1,0x30+wei3);
     
661.    DisplayOneChar(10,1,0x30+wei2);
     
662.    DisplayOneChar(11,1,'.');        
     
663.    DisplayOneChar(12,1,0x30+wei1);
     
664.    //DisplayOneChar(10,1,'.');
     
665.    DisplayOneChar(13,1,0x30+wei0);
     
666. }
     
667. void temer1() interrupt 1
     
668. { uchar temp;
     
669.   EX1=0;
     
670.   P1=0xfe;
     
671.   temp=P1;
     
672.   temp=temp&0xf0;
     
673.   if(temp!=0xf0)
     
674.   {
     
675.     delay(5);
     
676.         temp=P1;
     
677.     temp=temp&0xf0;
     
678.         while(temp!=0xf0)
     
679.         {
     
680.           temp=P1;
     
681.           switch(temp)
     
682.           {
     
683.             case 0xee:num=1;n=7;k=1;if(shift%2==0) s++;break;
     
684.             case 0xde:num=2;n=8;k=1;if(shift%2==0)s++;break;
     
685.             case 0xbe:num=3;n=9;k=1;if(shift%2==0)s++;break;
     
686.             case 0x7e:num=4;k='/';shift++;break;
     
687.           }
     
688.           while(temp!=0xf0)
     
689.           {
     
690.                    temp=P1;
     
691.         temp=temp&0xf0;
     
692.           }
     
693.         //DisplayOneChar((s+6),1,table2[num-1]);
     
694.         }
     
695.   }
     
696.   P1=0xfd;
     
697.   temp=P1;
     
698.   temp=temp&0xf0;
     
699.   if(temp!=0xf0)
     
700.   {
     
701.     delay(5);
     
702.         temp=P1;
     
703.     temp=temp&0xf0;
     
704.         while(temp!=0xf0)
     
705.         {
     
706.           temp=P1;
     
707.           switch(temp)
     
708.           {
     
709.             case 0xed:num=5;n=4;k=1;if(shift%2==0)s++;break;
     
710.             case 0xdd:num=6;n=5;k=1;if(shift%2==0)s++;break;
     
711.             case 0xbd:num=7;n=6;k=1;if(shift%2==0)s++;break;
     
712.                 case 0x7d:k='*';ncm=1;break;
     
713.           }
     
714.           while(temp!=0xf0)
     
715.           {
     
716.                    temp=P1;
     
717.         temp=temp&0xf0;
     
718.           }
     
719.         //DisplayOneChar(k+6,1,table2[num-1]);
     
720.         }
     
721.   }
     
722.   P1=0xfb;
     
723.   temp=P1;
     
724.   temp=temp&0xf0;
     
725.   if(temp!=0xf0)
     
726.   {
     
727.     delay(5);
     
728.         temp=P1;
     
729.     temp=temp&0xf0;
     
730.         while(temp!=0xf0)
     
731.         {
     
732.           temp=P1;
     
733.           switch(temp)
     
734.           {
     
735.             case 0xeb:num=9;n=1;k=1;if(shift%2==0)s++;break;
     
736.             case 0xdb:num=10;n=2;k=1;if(shift%2==0)s++;break;
     
737.             case 0xbb:num=11;n=3;k=1;if(shift%2==0)s++;break;
     
738.                 case 0x7b:k='-';sett++;break;
     
739.           }
     
740.           while(temp!=0xf0)
     
741.           {
     
742.                    temp=P1;
     
743.         temp=temp&0xf0;
     
744.           }
     
745. //        DisplayOneChar(k+6,1,table2[num-1]);
     
746. 
     
747.         }
     
748.   }
     
749.   P1=0xf7;
     
750.   temp=P1;
     
751.   temp=temp&0xf0;
     
752.   if(temp!=0xf0)
     
753.   {
     
754.     delay(5);
     
755.         temp=P1;
     
756.     temp=temp&0xf0;
     
757.         while(temp!=0xf0)
     
758.         {
     
759.           temp=P1;
     
760.           switch(temp)
     
761.           {
     
762.             case 0xe7:num=13;k=' ';break;
     
763.             case 0xd7:num=14;n=0;k=1;if(shift%2==0)s++;;break;
     
764.                 case 0xb7:num=16;k='=';break;
     
765.                 case 0x77:num=15;k=1;s++;break;
     
766.           }
     
767.           while(temp!=0xf0)
     
768.           {
     
769.                    temp=P1;
     
770.         temp=temp&0xf0;
     
771.           }
     
772.          }
     
773.    
     
774.   }
     
775.   EX1=1;
     
776. }
     
777. void com()interrupt 4
     
778. {
     
779. RI=0;
     
780. }
     
781. void start()  //開始數據傳送，開始位
     
782. {
     
783.         SDA=1;  //SDA初始化為高電平“1”
     
784.         SCL=1;  //開始數據傳送時，要求SCL為高電平“1”
     
785.         _nop_();
     
786.         _nop_();  //空操作兩個機器周期
     
787.         SDA=0;  //SDA的下降沿被認為是開始信號
     
788.         _nop_();
     
789.         _nop_();
     
790.         _nop_();
     
791.         _nop_();  //空操作四個機器周期
     
792.         SCL=0;  //SCL為低電平時，SDA上數據才允許變化（即允許以后的數據傳遞）
     
793. }
     
794. void stop()  //結束數據傳遞
     
795. {
     
796.         SDA=0;  //SDA初始化為低電平“0”
     
797.         _nop_();
     
798.         _nop_();  //空操作兩個機器周期
     
799.         SCL=1;  //結束數據傳送時，要求SCL為高電平“1”
     
800.         _nop_();
     
801.         _nop_();
     
802.         _nop_();
     
803.         _nop_();  //空操作四個機器周期
     
804.         SDA=1;  //SDA的上升沿被認為是結束信號
     
805. }
     
806. unsigned char ReadData()  //從AT24Cxx讀取數據，出口參數x，從AT24Cxx移入數據到MCU
     
807. {
     
808.         unsigned char i;
     
809.         unsigned char x;  //存儲從AT24Cxx中讀出的數據
     
810.         for(i=0;i<8;i++)
     
811.         {
     
812.                 SCL=1;  //SCL置為高電平
     
813.                 x<<=1;  //將x中的各二進位向左移一位
     
814.                 x|=(unsigned char)SDA;  //將SDA上的數據通過按位“或”運算存入x中
     
815.                 SCL=0;  //在SCL的下降沿讀出數據
     
816.         }
     
817.         return(x);  //將讀取的數據返還
     
818. }
     
819. bit WriteCurrent(unsigned char y)  //向AT23Cxx的當前地址寫入數據，入口參數y（存儲待寫入的數據），在調用此數據寫入函數前需首先調用開始start（），所以SCL=0
     
820. {
     
821.         unsigned char i, ack_bit;  //存儲應答位
     
822.         for(i=0;i<8;i++)  //循環移入8個位
     
823.         {
     
824.                 SDA=(bit)(y&0x80);  //通過按位“與”運算將最高位數據送到S，因為傳送時高位在前，低位在后
     
825.                 _nop_();  //空操作一個機器周期
     
826.                 SCL=1;  //在SCL的上升沿將數據寫入AT24Cxx
     
827.                 _nop_();
     
828.                 _nop_();  //空操作兩個機器周期
     
829.                 SCL=0;  //將SCL重新置為低電平，以在SCL線形成傳送數據所需的8個脈沖
     
830.                 y<<=1;  //將y中的各二進位向左移一位
     
831.         }
     
832.         SDA=1;  //發送設備（主機）應在時鐘脈沖的高電平期間（SCL=1）釋放SDA線，以讓SDA線轉由接收設備（AT24Cxx）控制
     
833.         _nop_();
     
834.         _nop_();  //空操作兩個機器周期
     
835.         SCL=1;  //根據上述規定，SCL應為高電平
     
836.         _nop_();
     
837.         _nop_();
     
838.         _nop_();
     
839.         _nop_();;  //空操作四個機器周期
     
840.         ack_bit=SDA;  //接收設備（AT24Cxx）向SDA送低電平，表示已經接收到一個字節，若送高電平，表示沒有收到，傳送異常
     
841.         SCL=0;  //SCL為低電平時，SDA上數據才允許變化（即允許以后的數據傳遞）
     
842.         return  ack_bit;  //返回AT24Cxx答應位
     
843. }
     
844. void WriteSet(unsigned char add,unsigned char dat)  //向AT24Cxx中的指定地址寫入數據，存儲地址add，存儲待寫入數據dat
     
845. //在指定地址add處寫入數據WriteCurrent
     
846. {
     
847.         start();  //開始數據傳遞
     
848.         WriteCurrent(OP_WRITE);  //選擇要操作的AT24Cxx芯片，并告知要對其寫入數據
     
849.         WriteCurrent(add);  //寫入指定地址
     
850.         WriteCurrent(dat);  //向當前地址（上面指定的地址）寫入數據
     
851.         stop();  //停止數據傳遞
     
852.         delay(4);  //一字節的寫入周期為1ms，最好延時1ms以上
     
853. }
     
854. unsigned char ReadCurrent()  //從AT24Cxx中的當前地址讀取數據，出口參數x
     
855. {
     
856.         unsigned char x;
     
857.         start();  //開始數據傳遞
     
858.         WriteCurrent(OP_READ);  //選擇要操作的AT24Cxx芯片，并告知要讀取其數據
     
859.         x=ReadData();  //將讀取的數據存入x
     
860.         stop();  //停止數據傳遞
     
861.         return x;  //返回讀取的數據
     
862. }
     
863. unsigned char ReadSet(unsigned char set_add)  //從AT24Cxx中的指定地址讀取數據，入口set_add，出口x
     
864. //在指定地址讀取
     
865. {
     
866.         start();  //開始數據傳遞
     
867.         WriteCurrent(OP_WRITE);  //選擇要操作的AT24Cxx芯片，并告知要對其寫入數據
     
868.         WriteCurrent(set_add);  //寫入指定地址
     
869.         return(ReadCurrent());  //從指定地址讀出數據并返回
     
870. }
     

復制代碼

所有資料51hei提供下載:
電子秤仿真設計.rar (134.55 KB, 下載次數: 207)

2018-11-19 11:23 上傳

點擊文件名下載附件
下載積分: 黑幣 -5

---

作者: qq974282228    時間: 2019-3-31 17:19
謝謝樓主分享！我用Proteus打開的效果:

51hei.png (19.32 KB, 下載次數: 41)

下載附件

2021-7-20 04:30 上傳

---

作者: 1994745550    時間: 2019-12-25 16:37
你這里面主機程序打不開啊

---

作者: 1994745550    時間: 2019-12-25 16:43
程序錯誤百出啊，源程序打不開，按照復制代碼報錯改半天

---

作者: 蟲蟲2020    時間: 2020-5-11 11:04

1994745550 發表于 2019-12-25 16:43
程序錯誤百出啊，源程序打不開，按照復制代碼報錯改半天

兄弟，可以把改好的程序發我一下嗎

---

作者: 老毛毛毛    時間: 2020-5-25 11:48
謝謝樓主分享！有一個文件路徑不對,我修改了一下

電子秤仿真設計.7z

2021-7-20 04:37 上傳

點擊文件名下載附件

下載積分: 黑幣 -5

71.85 KB, 下載次數: 23, 下載積分: 黑幣 -5

---

作者: 1960    時間: 2021-7-31 15:48
看看這個

電子秤仿真設計.rar

2021-7-31 15:48 上傳

點擊文件名下載附件

下載積分: 黑幣 -5

25.37 KB, 下載次數: 25, 下載積分: 黑幣 -5

---

作者: ZHOUMIN1519    時間: 2021-12-11 19:34

你好，我想問下那個從機是用來傳輸記錄數據的嗎，還有其他的作用嗎，下面那個從機刪掉的話沒有影響吧

---

作者: ZHOUMIN1519    時間: 2021-12-11 19:34

你好，我想問下那個從機是用來傳輸記錄數據的嗎，還有其他的作用嗎，下面那個從機刪掉的話沒有影響吧

---

歡迎光臨 (http://www.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影