【参赛】五位半台式万用表DIY

其实不想走

yangen 发表于 2016-2-3 20:43
感谢！！！！！

邮件已发。。。。

liquidator

如果搂主暂时不求精度，只是论证原理，都用国产器件多好，包括ADC，电压基准。

其实不想走

前两天在给面板打孔的时候，我的小台钻的皮带断了，手里也没有替换的，快过年了快递都停了，也买不到新的啦，台钻只能就此罢工了。台钻是我在DIY过程中所需要的重要工具，台钻罢工了，我的DIY也只能止步了，好在大面上基本完成，功能性已经不收影响了，就是外观以及一些细节方面没法完善了，只能等年后换个皮带再弄。
上一张英勇就义的小台钻的照片吧：
下面我就把简单粗糙的装配图发上了大家看一下，仪器的面板没装，现在看到的是面板里面的一块设备固定板。数码管显示屏也没有滤光片，照片拍出来效果不好，数字的可分辨度很差，大家将就看吧，将来有了面板再加上，到时候显示效果应该会好很多。还有就是档位量程指示只把一部分发光管装上了，也没有图案显示，现在只有简易的指示，毕竟现在软件还没把各个功能完善，装上也没效果。
内部图：
电压档开机显示图：
电流档开机显示图：
电阻档开机显示图：
自动手动量程指示：
开机演示视频：
开机演示视频

其实不想走

怎么把视频放到帖子里显示啊？以前我记得可以啊，怎么现在找不到选项了？

一杯清茶

楼主动手能力真强。赞一个！

Pro.Audio

顶了，真不错 。

ynkmljx

这个要支持一下！期待最后的结果。

pc128

支持，学习、佩服！看基准版，价格不菲

toolgood

牛人，这个也能DIY,牛！

luckyangman

做的真不错！支持折腾

其实不想走

给表的显示屏加了个临时滤光片，这样拍的照片和视频就能看清楚读数了。
发几个万用表的简单测试图片和视频，各位老师给指导指导。
现在的机子各量程都未经过校准和线性修正，基本都是最原始的测量数据，所以各档与对比表34401A相差较大，等以后有时间了再做修正。
先发个开机测试视频，之前发的那个看不清屏幕。
开机测试视频
1K电阻测试对比：

1K电阻测试视频
5K电阻测试对比：

5K电阻测试视频
10K电阻测试对比：

10K电阻测试视频
下面是电压档测试视频，因为没有稳定的低电压源，就用手持万用表测量一个5K电阻来产生一个小电压来测量。
电压档测试视频
通过视频可以看出250mV档最后1位跳的比较厉害，2.5V原始档位比较稳定。主要原因是250mV档位经过了一个x10的放大电路，本身放大电路的运放用的就是ICL7650斩波稳零运放，这种运放的最大缺点就是噪声很大，经过10倍放大，噪声也就被放大了10倍，所以读数就会跳的厉害。因为此原因，25V档最后一位跳的也比较厉害，这是电路本身缺陷造成的，没办法。计划以后改进时改用低噪声运放做放大。
电阻档还是很稳定的，因为电阻档用的是AD的5V原始量程，没经过任何放大。而且500Ω档位测试电流用的是10mA,测量小电阻，与我的HP34401A对比，比它还要稳定的多。

其实不想走

把单片机的程序发上来

1. /********************************************************************
   
2. * 文件名  ： LED显示 5位半万用表
   
3. * 描述    :  使用24M晶体 ， STC15F2K32S2单片机 ，LTC2400  ADC
   
4. * 创建人  ： CCA767，2016.1.28
   
5. * 版本号  ： 1.0
   
6. ***********************************************************************/
   
7. #include<STC15F2K60S2.H>   //定义STC15F2K32S2单片机特殊功能寄存器和位寄存器的。
   
8. #include <intrins.h>     //包含指令_nop_(); 延时一个机器周期。
   
9. #include<math.h>
   
10. 
    
11. #define uchar unsigned char
    
12. #define uint  unsigned int
    
13. 
    
14. #define AVE 30                          //平均值滤波次数
    
15. #define Vref 5.00025          //电压基准值
    
16. 
    
17. 
    
18. uchar code table1[] ={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};          //带小数点数字编码
    
19. uchar code table[10] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};          //不带小数点数字编码
    
20. 
    
21. 
    
22. 
    
23. sbit LE1=P3^6;      //继电器控制锁存器 锁存控制端 （低电平锁存）
    
24. sbit LE2=P3^5;                //模拟开关控制锁存器 锁存控制端 （低电平锁存）
    
25. sbit FUN_EN=P1^0;        //功能选择板模拟开关使能端
    
26. sbit FUN_A2=P1^1;        //功能选择板模拟开关地址口A2
    
27. sbit FUN_A1=P1^2;        //功能选择板模拟开关地址口A1
    
28. sbit FUN_A0=P1^3;        //功能选择板模拟开关地址口A0
    
29. 
    
30. 
    
31. 
    
32. sbit SCK=P5^4;        //定义LTC2400引脚 时钟口
    
33. sbit SDO=P5^5;        //LTC2400数据口       
    
34. sbit CS=P3^4;        //LTC2400片选口
    
35. 
    
36. 
    
37. long value;   //采样前滤波值  
    
38. uchar gear;          //档位标识符
    
39. uchar range;  //量程标识符
    
40. uchar add;    //超量程标识符
    
41. uchar red;    //减量程表示符
    
42. uchar AUTO;          //自动量程手动量程标识
    
43. long null;   //NULL值
    
44. long U;       //计算后测量值
    
45. uchar num;
    
46. long ZERO;
    
47. uchar n;
    
48. 
    
49. long get_v();
    
50. long filter();
    
51. void AUTO_ZERO();
    
52. void delay_ms(unsigned int i);                //延时函数 i*ms
    
53. void delay_us( uchar i);                                //延时函数  (i+1)*us
    
54. void LED_display(uchar i,uchar j);
    
55. void DCV_250mV();
    
56. void DCV_2500mV();
    
57. void DCV_25V();
    
58. void DCV_250V();
    
59. void ohms_2w_5M();
    
60. void ohms_2w_500K();
    
61. void ohms_2w_50K();
    
62. void ohms_2w_5K();
    
63. void ohms_2w_500();
    
64. void null_set();
    
65. void DCI_2mA();
    
66. void DCI_20mA();
    
67. void DCI_200mA();
    
68. void DCI_2A();
    
69. uchar keyboard();
    
70. void keyscan();
    
71. void display_v_Auto();
    
72. void display_V_Man();
    
73. void display_i_Auto();
    
74. void display_i_Man();
    
75. void display_ohms_Auto();
    
76. void display_ohms_Man();
    
77. void welcome(); //开机欢迎语 HELLO
    
78. 
    
79. 
    
80. void system_init()
    
81. {
    
82.         P1=0x00;
    
83.         LE1=1;   
    
84.         delay_ms(1);
    
85.         LE1=0;
    
86.         P1=0x45;        //5V,x1,1/1,5M ,ohms
    
87.         LE2=1;       
    
88.         delay_ms(1);
    
89.         LE2=0;
    
90.         CS=0;
    
91.         SCK=0;
    
92.         AUTO=1;
    
93. }
    
94. 
    
95. long filter()                //滤波函数
    
96. {
    
97.         long V=0;
    
98.         V=get_v();
    
99.         if(labs(V-value)>2000)         //限幅
    
100.                 value=V*AVE;          
     
101.         else
     
102.                 value=V+value-value/AVE;                 //一阶滤波
     
103.         return  value/AVE;                         //取平均值
     
104. }
     
105. void time_init()
     
106. {
     
107.         TMOD=0X00;
     
108.         TL0=(65536-40000)%256;
     
109.         TH0=(65536-40000)/256;
     
110.         TR0=1;
     
111.         ET0=1;
     
112.         EA=1;
     
113. }
     
114. /********************************************************************
     
115. * 名称 : 主函数                  
     
116. * 功能 :
     
117. * 输入 : 无                  
     
118. * 输出 : 无                    
     
119. ***********************************************************************/
     
120. void main()
     
121. {       
     
122.         P0M1=0x00;
     
123.         P0M0=0x00;
     
124.         P5M0=0x00;
     
125.         P5M1=0x20;
     
126.         P2M0=0xff;
     
127.         P2M1=0x00;
     
128.         P4M0=0xff;
     
129.         P4M1=0x00;
     
130.        
     
131. 
     
132.         welcome();
     
133. 
     
134.         system_init();
     
135.         AUTO_ZERO();
     
136.         time_init();
     
137.         delay_ms(2000);
     
138.        
     
139.         while(1)
     
140.                    {
     
141.                         keyscan();
     
142.                         if(n==3)
     
143.                         {
     
144.                                 AUTO_ZERO();
     
145.                         }
     
146.                         switch(gear)
     
147.                         {
     
148.                                 case 0:
     
149.                                         if(AUTO)
     
150.                                                 display_v_Auto();
     
151.                                         else
     
152.                                                 display_V_Man();
     
153.                                         break;
     
154.                                 case 1:
     
155.                                         if(AUTO)
     
156.                                                 display_ohms_Auto();
     
157.                                         else
     
158.                                                 display_ohms_Man();
     
159.                                         break;
     
160.                                 case 2:
     
161.                                         if(AUTO)
     
162.                                                 display_i_Auto();
     
163.                                         else
     
164.                                                 display_i_Man();
     
165.                                         break;
     
166.                         }                               
     
167.                     
     
168.                 }
     
169. 
     
170. }
     
171. 
     
172. void DCV_250mV()
     
173. {
     
174.         P1=0;
     
175.         LE1=1;
     
176.         delay_us(10);
     
177.         LE1=0;
     
178.         P1=0x45;  //x10.1/1
     
179.         LE2=1;
     
180.         delay_us(10);
     
181.         LE2=0;
     
182.         gear=0;               
     
183.         range=0; //量程标识符
     
184. }
     
185. void DCV_2500mV()
     
186. {
     
187.         P1=0;
     
188.         LE1=1;
     
189.         delay_us(5);
     
190.         LE1=0;
     
191. //        P1=0x41;   //x10,1/100
     
192.         P1=0x05;        //5V,x1,1/1,5M ,ohms
     
193. //        P1=0x03;
     
194. //        P1=0x35;        //5k ohms
     
195. //        P1=0x25;        //50k,ohms
     
196. //        P1=0x15;        //500k,ohms
     
197. //        P1=0x03;
     
198.         LE2=1;
     
199.         delay_us(5);
     
200.         LE2=0;
     
201. }
     
202. void DCV_25V()
     
203. {
     
204.         P1=0x04;
     
205.         LE1=1;
     
206.         delay_us(5);
     
207.         LE1=0;
     
208.         P1=0x41;   //x10,1/100
     
209. //        P1=0x43;
     
210.         LE2=1;
     
211.         delay_us(5);
     
212.         LE2=0;
     
213. }
     
214. 
     
215. void DCV_250V()
     
216. {
     
217.         P1=0x04;
     
218.         LE1=1;
     
219.         delay_us(5);
     
220.         LE1=0;
     
221.         P1=0x01;        //x1.1/100
     
222. //        P1=0x03;
     
223.         LE2=1;
     
224.         delay_us(5);
     
225.         LE2=0;
     
226. }
     
227. void ohms_2w_5M()
     
228. {
     
229.         P1=0x38;
     
230.         LE1=1;
     
231.         delay_us(5);
     
232.         LE1=0;
     
233.         P1=0x05;
     
234.         LE2=1;
     
235.         delay_us(5);
     
236.         LE2=0;
     
237.         gear=1;
     
238.         range=4; //量程标识符
     
239. }
     
240. void ohms_2w_500K()
     
241. {
     
242.         P1=0x38;
     
243.         LE1=1;
     
244.         delay_us(5);
     
245.         LE1=0;
     
246.         P1=0x15;
     
247.         LE2=1;
     
248.         delay_us(5);
     
249.         LE2=0;
     
250. }
     
251. void ohms_2w_50K()
     
252. {
     
253.         P1=0x38;
     
254.         LE1=1;
     
255.         delay_us(5);
     
256.         LE1=0;
     
257.         P1=0x25;
     
258.         LE2=1;
     
259.         delay_us(5);
     
260.         LE2=0;
     
261. }
     
262. void ohms_2w_5K()
     
263. {
     
264.         P1=0x38;
     
265.         LE1=1;
     
266.         delay_us(5);
     
267.         LE1=0;
     
268.         P1=0x35;
     
269.         LE2=1;
     
270.         delay_us(5);
     
271.         LE2=0;
     
272. }
     
273. void ohms_2w_500()
     
274. {
     
275.         P1=0x78;
     
276.         LE1=1;
     
277.         delay_us(5);
     
278.         LE1=0;
     
279.         P1=0x35;
     
280.         LE2=1;
     
281.         delay_us(5);
     
282.         LE2=0;
     
283. }
     
284. void null_set()
     
285. {
     
286.         switch(gear)
     
287.         {
     
288.                 case 0: break;
     
289.                 case 1:
     
290.                         null=U;
     
291.                         break;
     
292.         }                       
     
293. }
     
294. void DCI_2mA()
     
295. {
     
296.         P1=0x02;
     
297.         LE1=1;
     
298.         delay_us(10);
     
299.         LE1=0;
     
300.         P1=0x49;  
     
301.         LE2=1;
     
302.         delay_us(10);
     
303.         LE2=0;
     
304.         gear=2;               
     
305.         range=0; //量程标识符
     
306. }
     
307. void DCI_20mA()
     
308. {
     
309.         P1=0x0a;
     
310.         LE1=1;
     
311.         delay_us(10);
     
312.         LE1=0;
     
313.         P1=0x49;  
     
314.         LE2=1;
     
315.         delay_us(10);
     
316.         LE2=0;
     
317. }
     
318. void DCI_200mA()
     
319. {
     
320.         P1=0x12;
     
321.         LE1=1;
     
322.         delay_us(10);
     
323.         LE1=0;
     
324.         P1=0x49;  
     
325.         LE2=1;
     
326.         delay_us(10);
     
327.         LE2=0;
     
328. }
     
329. void DCI_2A()
     
330. {
     
331.         P1=0x06;
     
332.         LE1=1;
     
333.         delay_us(10);
     
334.         LE1=0;
     
335.         P1=0x49;  
     
336.         LE2=1;
     
337.         delay_us(10);
     
338.         LE2=0;
     
339. }
     
340. uchar keyboard()
     
341. {
     
342.         uchar i, temp1,temp2;
     
343.         for(i=0;i<4;i++)
     
344.         {
     
345.                 P0=~(1<<i);
     
346.                 temp1=P0&0xf0;
     
347.                 if(temp1!=0xf0)
     
348.                 {
     
349.                         delay_ms(10);
     
350.                         temp2=P0&0xf0;
     
351.                         if(temp1==temp2)
     
352.                         {
     
353.                                 if(temp1==0x70) //7
     
354.                                 {
     
355.                                         while(temp1!=0xf0)
     
356.                                         {
     
357.                                                 temp1=P0&0xf0;
     
358.                                         }
     
359.                                         return i*4+0;
     
360.                                 }
     
361.                                 if(temp1==0xd0) //5
     
362.                                 {
     
363.                                         while(temp1!=0xf0)
     
364.                                         {
     
365.                                                 temp1=P0&0xf0;
     
366.                                         }
     
367.                                         return i*4+1;
     
368.                                 }
     
369.                                 if(temp1==0xe0) //4
     
370.                                 {
     
371.                                         while(temp1!=0xf0)
     
372.                                         {
     
373.                                                 temp1=P0&0xf0;
     
374.                                         }
     
375.                                         return i*4+2;
     
376.                                 }
     
377.                         }
     
378.                         else
     
379.                                 return 16;
     
380.                 }
     
381.         }
     
382. }
     
383. 
     
384. /*******************************************************************************
     
385.                                                                         |
     
386.          6                         4                          5                |         2                         0                         1
     
387.         DCV         DCI         OHMS        |        ***                        ***                        NULL
     
388. ------------------------------------------------------------------------------
     
389.                                                                         |
     
390.          10                         8                         9                |        14                        12                        13
     
391.          <                         >                        ***                |        ***                        Auto                ***
     
392.                                                                                                         Man
     
393. *******************************************************************************/
     
394. void keyscan()
     
395. {
     
396.         uchar KEY;
     
397.         KEY=keyboard();
     
398.         switch(KEY)
     
399.         {
     
400.                 case 6:
     
401.                         DCV_250mV();
     
402.                         break;
     
403.                 case 5:
     
404.                         ohms_2w_5M();
     
405.                         break;
     
406.                 case 1:
     
407.                         null_set();
     
408.                         break;
     
409.                 case 4:
     
410.                         DCI_2mA();
     
411.                         break;
     
412.                 case 10:
     
413.                         if(range>0)
     
414.                                 range--;
     
415.                         break;
     
416.                 case 8:
     
417.                         if(gear==1)
     
418.                         {
     
419.                                 if(range<4)
     
420.                                 range++;
     
421.                         }
     
422.                         else
     
423.                         {
     
424.                                 if(range<3)
     
425.                                 range++;
     
426.                         }
     
427.                         break;
     
428.                 case 12:
     
429.                         if(AUTO==1)
     
430.                                 AUTO=0;
     
431.                         else
     
432.                                 AUTO=1;
     
433.                         break;
     
434.         }
     
435. }
     
436. void display_v_Auto()
     
437. {
     
438.     long V; uchar SIG=0,NEG=0;
     
439.         V=filter();
     
440.         if(V&0x2000000)
     
441.         {       
     
442.                 V=V-33554432;
     
443.                 if(V<ZERO)
     
444.                         U=ZERO-V;
     
445.                 else
     
446.                 {
     
447.                         U=V-ZERO;
     
448.                         NEG=1;
     
449.                 }
     
450.                 U=U*Vref/1.6777216;       
     
451.         }
     
452.         else
     
453.         {       
     
454.                 U=(33554432-V)*Vref/1.6777216 ;
     
455.                 U=U+25001100;
     
456.         }       
     
457.         if(U>25500000)
     
458.                 {
     
459.                         add++;
     
460.                 }
     
461.         if(U<2500000)
     
462.         {
     
463.                 red++;
     
464.         }
     
465.         if(add==2)
     
466.         {       
     
467.                 if(range<3)
     
468.                 {
     
469.                         range++;
     
470.                 }
     
471.                 add=0;
     
472.         }
     
473.         if (red==2)
     
474.         {
     
475.                 if(range>0)
     
476.                 {
     
477.                         range--;
     
478.                 }
     
479.                 red=0;
     
480.         }
     
481.         if(NEG)       
     
482.         {
     
483.                 LED_display(191,0);
     
484.         }
     
485.         else
     
486.         {
     
487.                 LED_display(255,0);
     
488.         }
     
489.         switch (range)
     
490.         {
     
491.                 case 0:
     
492.                                 DCV_250mV();
     
493.                             LED_display(table[U/10000000],1);       
     
494.                                 LED_display(table[U%10000000/1000000],2);       
     
495.                                 LED_display(table1[U%1000000/100000],3);       
     
496.                                 LED_display(table[U%100000/10000],4);
     
497.                                 LED_display(table[U%10000/1000],5);
     
498.                                 LED_display(table[U%1000/100],6);       
     
499.                             LED_display(0xbf,7);
     
500.                                 LED_display(0xff,8);
     
501.                                 LED_display(0xfe,9);
     
502.                                 break;                                 
     
503.                 case 1:
     
504.                                 DCV_2500mV();
     
505.                                 LED_display(table1[U/10000000],1);       
     
506.                                 LED_display(table[U%10000000/1000000],2);       
     
507.                                 LED_display(table[U%1000000/100000],3);       
     
508.                                 LED_display(table[U%100000/10000],4);
     
509.                                 LED_display(table[U%10000/1000],5);
     
510.                                 LED_display(table[U%1000/100],6);
     
511.                                 LED_display(0xef,7);
     
512.                                 LED_display(0xfe,9);
     
513.                                 break;
     
514.                 case 2:
     
515.                                 DCV_25V();
     
516.                                 if(NEG)
     
517.                                         U=U*1.00024-650;
     
518.                                 else
     
519.                                         U=U*1.00024+650;
     
520.                                 LED_display(table[U/10000000],1);       
     
521.                                 LED_display(table1[U%10000000/1000000],2);       
     
522.                                 LED_display(table[U%1000000/100000],3);       
     
523.                                 LED_display(table[U%100000/10000],4);
     
524.                                 LED_display(table[U%10000/1000],5);
     
525.                                 LED_display(table[U%1000/100],6);
     
526.                                 LED_display(0xef,7);
     
527.                                 LED_display(0xfe,9);
     
528.                                 break;
     
529.                        
     
530.                 case 3:
     
531.                                 DCV_250V();
     
532.                                 if(NEG)
     
533.                                         U=U*1.00024-65;
     
534.                                 else
     
535.                                         U=U*1.00024+65;
     
536.                                 LED_display(table[U/10000000],1);       
     
537.                                 LED_display(table[U%10000000/1000000],2);       
     
538.                                 LED_display(table1[U%1000000/100000],3);       
     
539.                                 LED_display(table[U%100000/10000],4);
     
540.                                 LED_display(table[U%10000/1000],5);
     
541.                                 LED_display(table[U%1000/100],6);
     
542.                                 LED_display(0xef,7);
     
543.                                 LED_display(0xfe,9);
     
544.                                 break;
     
545.         }
     
546. 
     
547. }
     
548. void display_V_Man()
     
549. {
     
550.         long V; uchar SIG=0,NEG=0;
     
551.         V=filter();
     
552.         if(V&0x2000000)
     
553.         {       
     
554.                 V=V-33554432;       
     
555.                 if(V<ZERO)
     
556.                         U=ZERO-V;
     
557.                 else
     
558.                 {
     
559.                         U=V-ZERO;
     
560.                         NEG=1;
     
561.                 }
     
562.                 U=U*Vref/1.6777216;               
     
563.         }
     
564.         else
     
565.         {       
     
566.                 U=(33554432-V)*Vref/1.6777216 ;
     
567.                 U=U+25001100;
     
568.         }       
     
569.         if(NEG)       
     
570.         {
     
571.                 LED_display(191,0);
     
572.         }
     
573.         else
     
574.         {
     
575.                 LED_display(255,0);
     
576.         }
     
577.         switch (range)
     
578.         {
     
579.                 case 0:
     
580.                                 DCV_250mV();
     
581.                             LED_display(table[U/10000000],1);       
     
582.                                 LED_display(table[U%10000000/1000000],2);       
     
583.                                 LED_display(table1[U%1000000/100000],3);       
     
584.                                 LED_display(table[U%100000/10000],4);
     
585.                                 LED_display(table[U%10000/1000],5);
     
586.                                 LED_display(table[U%1000/100],6);       
     
587.                             LED_display(0xbf,7);
     
588.                                 LED_display(0xff,8);
     
589.                                 LED_display(0x7e,9);
     
590.                                 break;                                 
     
591.                 case 1:
     
592.                                 DCV_2500mV();
     
593.                                 LED_display(table1[U/10000000],1);       
     
594.                                 LED_display(table[U%10000000/1000000],2);       
     
595.                                 LED_display(table[U%1000000/100000],3);       
     
596.                                 LED_display(table[U%100000/10000],4);
     
597.                                 LED_display(table[U%10000/1000],5);
     
598.                                 LED_display(table[U%1000/100],6);
     
599.                                 LED_display(0xef,7);
     
600.                                 LED_display(0x7e,9);
     
601.                                 break;
     
602.                 case 2:
     
603.                                 DCV_25V();
     
604.                                 if(NEG)
     
605.                                         U=U*1.00024-650;
     
606.                                 else
     
607.                                         U=U*1.00024+650;
     
608.                                 LED_display(table[U/10000000],1);       
     
609.                                 LED_display(table1[U%10000000/1000000],2);       
     
610.                                 LED_display(table[U%1000000/100000],3);       
     
611.                                 LED_display(table[U%100000/10000],4);
     
612.                                 LED_display(table[U%10000/1000],5);
     
613.                                 LED_display(table[U%1000/100],6);
     
614.                                 LED_display(0xef,7);
     
615.                                 LED_display(0x7e,9);
     
616.                                 break;
     
617.                        
     
618.                 case 3:
     
619.                                 DCV_250V();
     
620.                                 if(NEG)
     
621.                                         U=U*1.00024-65;
     
622.                                 else
     
623.                                         U=U*1.00024+65;
     
624.                                 LED_display(table[U/10000000],1);       
     
625.                                 LED_display(table[U%10000000/1000000],2);       
     
626.                                 LED_display(table1[U%1000000/100000],3);       
     
627.                                 LED_display(table[U%100000/10000],4);
     
628.                                 LED_display(table[U%10000/1000],5);
     
629.                                 LED_display(table[U%1000/100],6);
     
630.                                 LED_display(0xef,7);
     
631.                                 LED_display(0x7e,9);
     
632.                                 break;
     
633.         }
     
634. }
     
635. void display_i_Auto()
     
636. {
     
637.         long V; uchar SIG=0,NEG=0;
     
638.         V=filter();
     
639.         if(V&0x2000000)
     
640.         {       
     
641.                 V=V-33554432;
     
642.                 if(V<ZERO)
     
643.                         U=ZERO-V;
     
644.                 else
     
645.                 {
     
646.                         U=V-ZERO;
     
647.                         NEG=1;
     
648.                 }
     
649.                 U=U*Vref/1.6777216;       
     
650.         }
     
651.         else
     
652.         {       
     
653.                 U=(33554432-V)*Vref/1.6777216 ;
     
654.                 U=U+25001100;
     
655.         }       
     
656.        
     
657.         if(U>25500000)
     
658.                 {
     
659.                         add++;
     
660.                 }
     
661.         if(U<2500000)
     
662.         {
     
663.                 red++;
     
664.         }
     
665.         if(add==2)
     
666.         {       
     
667.                 if(range<3)
     
668.                 {
     
669.                         range++;
     
670.                 }
     
671.                 add=0;
     
672.         }
     
673.         if (red==2)
     
674.         {
     
675.                 if(range>0)
     
676.                 {
     
677.                         range--;
     
678.                 }
     
679.                 red=0;
     
680.         }
     
681.        
     
682.         if(NEG)       
     
683.         {
     
684.                 LED_display(191,0);
     
685.         }
     
686.         else
     
687.         {
     
688.                 LED_display(255,0);
     
689.         }
     
690.         switch (range)
     
691.         {
     
692.                 case 0:
     
693.                                 DCI_2mA();
     
694.                             LED_display(table1[U/10000000],1);       
     
695.                                 LED_display(table[U%10000000/1000000],2);       
     
696.                                 LED_display(table[U%1000000/100000],3);       
     
697.                                 LED_display(table[U%100000/10000],4);
     
698.                                 LED_display(table[U%10000/1000],5);
     
699.                                 LED_display(table[U%1000/100],6);       
     
700.                             LED_display(0xbf,7);
     
701.                                 LED_display(0xff,8);
     
702.                                 LED_display(0xfd,9);
     
703.                                 break;                                 
     
704.                 case 1:
     
705.                                 DCI_20mA();
     
706.                                 LED_display(table[U/10000000],1);       
     
707.                                 LED_display(table1[U%10000000/1000000],2);       
     
708.                                 LED_display(table[U%1000000/100000],3);       
     
709.                                 LED_display(table[U%100000/10000],4);
     
710.                                 LED_display(table[U%10000/1000],5);
     
711.                                 LED_display(table[U%1000/100],6);
     
712.                                 LED_display(0xef,7);
     
713.                                 LED_display(0xfd,9);
     
714.                                 break;
     
715.                 case 2:
     
716.                                 DCI_200mA();
     
717.                                 LED_display(table[U/10000000],1);       
     
718.                                 LED_display(table[U%10000000/1000000],2);       
     
719.                                 LED_display(table1[U%1000000/100000],3);       
     
720.                                 LED_display(table[U%100000/10000],4);
     
721.                                 LED_display(table[U%10000/1000],5);
     
722.                                 LED_display(table[U%1000/100],6);
     
723.                                 LED_display(0xef,7);
     
724.                                 LED_display(0xfd,9);
     
725.                                 break;
     
726.                        
     
727.                 case 3:
     
728.                                 DCI_2A();
     
729.                                 LED_display(table1[U/10000000],1);       
     
730.                                 LED_display(table[U%10000000/1000000],2);       
     
731.                                 LED_display(table[U%1000000/100000],3);       
     
732.                                 LED_display(table[U%100000/10000],4);
     
733.                                 LED_display(table[U%10000/1000],5);
     
734.                                 LED_display(table[U%1000/100],6);
     
735.                                 LED_display(0xef,7);
     
736.                                 LED_display(0xfd,9);
     
737.                                 break;
     
738.         }
     
739. }
     
740. void display_i_Man()
     
741. {
     
742.         long V; uchar SIG=0,NEG=0;
     
743.         V=filter();
     
744.         if(V&0x2000000)
     
745.         {       
     
746.                 V=V-33554432;
     
747.                 if(V<ZERO)
     
748.                         U=ZERO-V;
     
749.                 else
     
750.                 {
     
751.                         U=V-ZERO;
     
752.                         NEG=1;
     
753.                 }
     
754.                 U=U*Vref/1.6777216;       
     
755.         }
     
756.         else
     
757.         {
     
758.                 U=(33554432-V)*Vref/1.6777216 ;
     
759.                 U=U+25001100;
     
760.         }       
     
761.         if(NEG)       
     
762.         {
     
763.                 LED_display(191,0);
     
764.         }
     
765.         else
     
766.         {
     
767.                 LED_display(255,0);
     
768.         }
     
769.         switch (range)
     
770.         {
     
771.                 case 0:
     
772.                                 DCI_2mA();
     
773.                             LED_display(table1[U/10000000],1);       
     
774.                                 LED_display(table[U%10000000/1000000],2);       
     
775.                                 LED_display(table[U%1000000/100000],3);       
     
776.                                 LED_display(table[U%100000/10000],4);
     
777.                                 LED_display(table[U%10000/1000],5);
     
778.                                 LED_display(table[U%1000/100],6);       
     
779.                             LED_display(0xbf,7);
     
780.                                 LED_display(0xff,8);
     
781.                                 LED_display(0x7d,9);
     
782.                                 break;                                 
     
783.                 case 1:
     
784.                                 DCI_20mA();
     
785.                                 LED_display(table[U/10000000],1);       
     
786.                                 LED_display(table1[U%10000000/1000000],2);       
     
787.                                 LED_display(table[U%1000000/100000],3);       
     
788.                                 LED_display(table[U%100000/10000],4);
     
789.                                 LED_display(table[U%10000/1000],5);
     
790.                                 LED_display(table[U%1000/100],6);
     
791.                                 LED_display(0xef,7);
     
792.                                 LED_display(0x7d,9);
     
793.                                 break;
     
794.                 case 2:
     
795.                                 DCI_200mA();
     
796.                                 LED_display(table[U/10000000],1);       
     
797.                                 LED_display(table[U%10000000/1000000],2);       
     
798.                                 LED_display(table1[U%1000000/100000],3);       
     
799.                                 LED_display(table[U%100000/10000],4);
     
800.                                 LED_display(table[U%10000/1000],5);
     
801.                                 LED_display(table[U%1000/100],6);
     
802.                                 LED_display(0xef,7);
     
803.                                 LED_display(0x7d,9);
     
804.                                 break;
     
805.                        
     
806.                 case 3:
     
807.                                 DCI_2A();
     
808.                                 LED_display(table1[U/10000000],1);       
     
809.                                 LED_display(table[U%10000000/1000000],2);       
     
810.                                 LED_display(table[U%1000000/100000],3);       
     
811.                                 LED_display(table[U%100000/10000],4);
     
812.                                 LED_display(table[U%10000/1000],5);
     
813.                                 LED_display(table[U%1000/100],6);
     
814.                                 LED_display(0xef,7);
     
815.                                 LED_display(0x7d,9);
     
816.                                 break;
     
817.         }
     
818. }
     

复制代码

其实不想走

1. void display_ohms_Auto()
   
2. {
   
3.         long V; uchar SIG=0,NEG=0;
   
4.         V=filter();
   
5.         if(!(V&0x2000000))
   
6.         {
   
7.                 SIG=1;
   
8.                        
   
9.         }
   
10.         if(V&0x2000000)
    
11.         {
    
12.                 V=V-33554432;
    
13.                 U=V*Vref/1.6777216;       
    
14.         }
    
15. 
    
16.         else
    
17.                 {
    
18.                         U=(33554432-V)*Vref/1.6777216 ;
    
19.                 }
    
20.        
    
21.         if(U>55000000)
    
22.                 {
    
23.                         add++;
    
24.                 }
    
25.         if(U<5500000)
    
26.         {
    
27.                 red++;
    
28.         }
    
29.         if(add>=1)
    
30.         {       
    
31.                 if(range<4)
    
32.                 {
    
33.                         range++;
    
34.                 }
    
35.                 add=0;
    
36.         }
    
37.         if (red>=1)
    
38.         {
    
39.                 if(range>0)
    
40.                 {
    
41.                         range--;
    
42.                 }
    
43.                 red=0;
    
44.         }
    
45. 
    
46.         LED_display(0xff,0);
    
47. 
    
48.         switch (range)
    
49.         {       
    
50.                 case 0:
    
51.                                 ohms_2w_500();
    
52.                                 U=U-null;
    
53.                                 if(U<0)
    
54.                                         U=0;          
    
55.                                 LED_display(table[U/10000000],1);       
    
56.                                 LED_display(table[U%10000000/1000000],2);       
    
57.                                 LED_display(table1[U%1000000/100000],3);       
    
58.                                 LED_display(table[U%100000/10000],4);
    
59.                                 LED_display(table[U%10000/1000],5);
    
60.                                 LED_display(table[U%1000/100],6);
    
61.                                 LED_display(0xfb,7);
    
62.                                 LED_display(0xfb,9);
    
63.                                 break;
    
64.                 case 1:
    
65.                                 ohms_2w_5K();
    
66.                                 U=U-null/10;
    
67.                                 if(U<0)
    
68.                                         U=0;
    
69.                             LED_display(table1[U/10000000],1);       
    
70.                                 LED_display(table[U%10000000/1000000],2);       
    
71.                                 LED_display(table[U%1000000/100000],3);       
    
72.                                 LED_display(table[U%100000/10000],4);
    
73.                                 LED_display(table[U%10000/1000],5);
    
74.                                 LED_display(table[U%1000/100],6);
    
75.                                 LED_display(0xfe,7);
    
76.                                 LED_display(0xfb,9);
    
77.                                 break;                                 
    
78.                 case 2:
    
79.                                 ohms_2w_50K();
    
80.                                 U=U*0.99996;
    
81.                                 U=U-null/100;
    
82.                                 if(U<0)
    
83.                                         U=0;
    
84.                                 LED_display(table[U/10000000],1);       
    
85.                                 LED_display(table1[U%10000000/1000000],2);       
    
86.                                 LED_display(table[U%1000000/100000],3);       
    
87.                                 LED_display(table[U%100000/10000],4);
    
88.                                 LED_display(table[U%10000/1000],5);
    
89.                                 LED_display(table[U%1000/100],6);
    
90.                                 LED_display(0xfe,7);
    
91.                                 LED_display(0xfb,9);
    
92.                                 break;
    
93.                 case 3:
    
94.                                 ohms_2w_500K();
    
95.                                 U=U*1.00016;
    
96.                                 U=U-null/1000;
    
97.                                 if(U<0)
    
98.                                         U=0;
    
99.                                 LED_display(table[U/10000000],1);       
    
100.                                 LED_display(table[U%10000000/1000000],2);       
     
101.                                 LED_display(table1[U%1000000/100000],3);       
     
102.                                 LED_display(table[U%100000/10000],4);
     
103.                                 LED_display(table[U%10000/1000],5);
     
104.                                 LED_display(table[U%1000/100],6);
     
105.                                 LED_display(0xfe,7);
     
106.                                 LED_display(0xff,8);
     
107.                                 LED_display(0xfb,9);
     
108.                                 break;
     
109.                        
     
110.                 case 4:
     
111.                                 ohms_2w_5M();
     
112.                                 U=U-null/10000;
     
113.                                 if(U<0)                                                                                                                                                                                         
     
114.                                         U=0;
     
115.                                 if(U<56000000)
     
116.                                 {
     
117.                                 LED_display(table1[U/10000000],1);       
     
118.                                 LED_display(table[U%10000000/1000000],2);       
     
119.                                 LED_display(table[U%1000000/100000],3);       
     
120.                                 LED_display(table[U%100000/10000],4);
     
121.                                 LED_display(table[U%10000/1000],5);
     
122.                                 LED_display(table[U%1000/100],6);
     
123.                                 LED_display(0xbf,8);
     
124.                                 LED_display(0xff,7);
     
125.                                 LED_display(0xfb,9);
     
126.                                 }
     
127.                                 else
     
128.                                 {       
     
129.                                 LED_display(191,1);       
     
130.                                 LED_display(191,2);       
     
131.                                 LED_display(191,3);       
     
132.                                 LED_display(191,4);
     
133.                                 LED_display(191,5);
     
134.                                 LED_display(191,6);
     
135.                                 LED_display(0xbf,8);
     
136.                                 LED_display(0xff,7);
     
137.                                 LED_display(0xfb,9);
     
138.                                 }
     
139.                                 break;
     
140.         }
     
141. 
     
142. }
     
143. void display_ohms_Man()
     
144. {
     
145.         long V; uchar SIG=0,NEG=0;
     
146.         V=filter();
     
147.         if(!(V&0x2000000))
     
148.         {
     
149.                 SIG=1;               
     
150.         }
     
151.         if(V&0x2000000)
     
152.         {
     
153.                 V=V-33554432;
     
154.                 U=V*Vref/1.6777216;       
     
155.         }
     
156.         else
     
157.         {
     
158.                 U=(33554432-V)*Vref/1.6777216;
     
159.         }
     
160.         LED_display(0xff,0);
     
161.         switch (range)
     
162.         {       
     
163.                 case 0:
     
164.                                 ohms_2w_500();
     
165.                                 U=U-null;
     
166.                                 if(U<0)
     
167.                                         U=0;
     
168.                                 if(U<56000000)
     
169.                                 {
     
170.                                 LED_display(table[U/10000000],1);       
     
171.                                 LED_display(table[U%10000000/1000000],2);       
     
172.                                 LED_display(table1[U%1000000/100000],3);       
     
173.                                 LED_display(table[U%100000/10000],4);
     
174.                                 LED_display(table[U%10000/1000],5);
     
175.                                 LED_display(table[U%1000/100],6);
     
176.                                 LED_display(0xfb,7);
     
177.                                 LED_display(0x7b,9);
     
178.                                 }
     
179.                                 else
     
180.                                 {       
     
181.                                 LED_display(191,1);       
     
182.                                 LED_display(191,2);       
     
183.                                 LED_display(191,3);       
     
184.                                 LED_display(191,4);
     
185.                                 LED_display(191,5);
     
186.                                 LED_display(191,6);
     
187.                                 LED_display(0xff,8);
     
188.                                 LED_display(0xfb,7);
     
189.                                 LED_display(0x7b,9);
     
190.                                 }
     
191.                                 break;
     
192.                 case 1:
     
193.                                 ohms_2w_5K();
     
194.                                 U=U-null/10;
     
195.                                 if(U<0)
     
196.                                         U=0;
     
197.                                 if(U<56000000)
     
198.                                 {
     
199.                             LED_display(table1[U/10000000],1);       
     
200.                                 LED_display(table[U%10000000/1000000],2);       
     
201.                                 LED_display(table[U%1000000/100000],3);       
     
202.                                 LED_display(table[U%100000/10000],4);
     
203.                                 LED_display(table[U%10000/1000],5);
     
204.                                 LED_display(table[U%1000/100],6);
     
205.                                 LED_display(0xfe,7);
     
206.                                 LED_display(0x7b,9);
     
207.                                 }
     
208.                                 else
     
209.                                 {       
     
210.                                 LED_display(191,1);       
     
211.                                 LED_display(191,2);       
     
212.                                 LED_display(191,3);       
     
213.                                 LED_display(191,4);
     
214.                                 LED_display(191,5);
     
215.                                 LED_display(191,6);
     
216.                                 LED_display(0xff,8);
     
217.                                 LED_display(0xfe,7);
     
218.                                 LED_display(0x7b,9);
     
219.                                 }
     
220.                                 break;                                 
     
221.                 case 2:
     
222.                                 ohms_2w_50K();
     
223.                                 U=U*0.99996;
     
224.                                 U=U-null/100;
     
225.                                 if(U<0)
     
226.                                         U=0;
     
227.                                 if(U<56000000)
     
228.                                 {
     
229.                                 LED_display(table[U/10000000],1);       
     
230.                                 LED_display(table1[U%10000000/1000000],2);       
     
231.                                 LED_display(table[U%1000000/100000],3);       
     
232.                                 LED_display(table[U%100000/10000],4);
     
233.                                 LED_display(table[U%10000/1000],5);
     
234.                                 LED_display(table[U%1000/100],6);
     
235.                                 LED_display(0xfe,7);
     
236.                                 LED_display(0x7b,9);
     
237.                                 }
     
238.                                 else
     
239.                                 {       
     
240.                                 LED_display(191,1);       
     
241.                                 LED_display(191,2);       
     
242.                                 LED_display(191,3);       
     
243.                                 LED_display(191,4);
     
244.                                 LED_display(191,5);
     
245.                                 LED_display(191,6);
     
246.                                 LED_display(0xff,8);
     
247.                                 LED_display(0xfe,7);
     
248.                                 LED_display(0x7b,9);
     
249.                                 }
     
250.                                 break;
     
251.                 case 3:
     
252.                                 ohms_2w_500K();
     
253.                                 U=U*1.00016;
     
254.                                 U=U-null/1000;
     
255.                                 if(U<0)
     
256.                                         U=0;
     
257.                                 if(U<56000000)
     
258.                                 {
     
259.                                 LED_display(table[U/10000000],1);       
     
260.                                 LED_display(table[U%10000000/1000000],2);       
     
261.                                 LED_display(table1[U%1000000/100000],3);       
     
262.                                 LED_display(table[U%100000/10000],4);
     
263.                                 LED_display(table[U%10000/1000],5);
     
264.                                 LED_display(table[U%1000/100],6);
     
265.                                 LED_display(0xfe,7);
     
266.                                 LED_display(0xff,8);
     
267.                                 LED_display(0x7b,9);
     
268.                                 }
     
269.                                 else
     
270.                                 {       
     
271.                                 LED_display(191,1);       
     
272.                                 LED_display(191,2);       
     
273.                                 LED_display(191,3);       
     
274.                                 LED_display(191,4);
     
275.                                 LED_display(191,5);
     
276.                                 LED_display(191,6);
     
277.                                 LED_display(0xff,8);
     
278.                                 LED_display(0xfe,7);
     
279.                                 LED_display(0x7b,9);
     
280.                                 }
     
281.                                 break;
     
282.                        
     
283.                 case 4:
     
284.                                 ohms_2w_5M();
     
285.                                 U=U-null/10000;
     
286.                                 if(U<0)                                                                                                                                                                                         
     
287.                                         U=0;
     
288.                                 if(U<56000000)
     
289.                                 {
     
290.                                 LED_display(table1[U/10000000],1);       
     
291.                                 LED_display(table[U%10000000/1000000],2);       
     
292.                                 LED_display(table[U%1000000/100000],3);       
     
293.                                 LED_display(table[U%100000/10000],4);
     
294.                                 LED_display(table[U%10000/1000],5);
     
295.                                 LED_display(table[U%1000/100],6);
     
296.                                 LED_display(0xbf,8);
     
297.                                 LED_display(0xff,7);
     
298.                                 LED_display(0x7b,9);
     
299.                                 }
     
300.                                 else
     
301.                                 {       
     
302.                                 LED_display(191,1);       
     
303.                                 LED_display(191,2);       
     
304.                                 LED_display(191,3);       
     
305.                                 LED_display(191,4);
     
306.                                 LED_display(191,5);
     
307.                                 LED_display(191,6);
     
308.                                 LED_display(0xbf,8);
     
309.                                 LED_display(0xff,7);
     
310.                                 LED_display(0x7b,9);
     
311.                                 }
     
312.                                 break;
     
313.         }
     
314. }
     
315. long get_v()
     
316. {
     
317.          uchar i;         long V=0;
     
318. loop:if(SDO==0)           
     
319.                 {
     
320.                           
     
321.                         for(i=0;i<2;i++)
     
322.                                 {
     
323.                                         SCK=1;
     
324.                                         delay_us(5);                       
     
325.                                         SCK=0;
     
326.                                         delay_us(5);
     
327.                                 }
     
328.                
     
329.                         for(i=0;i<26;i++)
     
330.                                 {       
     
331.                                         V<<=1;
     
332.                                         SCK=1;
     
333.                                         delay_us(5);
     
334.                                         if(SDO==1)
     
335.                                                 V++;       
     
336.                                         SCK=0;                               
     
337.                                         delay_us(5);
     
338.                                 }
     
339.                          for(i=0;i<4;i++)
     
340.                                 {
     
341.                                         SCK=1;
     
342.                                         delay_us(5);
     
343.                                         SCK=0;
     
344.                                         delay_us(5);
     
345.                                 }                         
     
346.                  }
     
347.         else goto loop;
     
348.         return V;
     
349.          
     
350. }
     
351. 
     
352. 
     
353. void delay_ms(unsigned int i)  //执行此函数延时 i ms。    （比较精确）                            
     
354. {
     
355.         unsigned char j,k;
     
356.         do
     
357.         {
     
358.                 j = 44;
     
359.                 do
     
360.                 {
     
361.                         k = 54;
     
362.                         do
     
363.                         {
     
364.                                 _nop_();
     
365.                                 _nop_();
     
366.                                 _nop_();
     
367.                                 _nop_();
     
368.                                 _nop_();
     
369.                                 _nop_();
     
370.                         }
     
371.                         while(--k);     
     
372.                 }
     
373.                 while(--j);
     
374.         }
     
375.         while(--i);
     
376. 
     
377. 
     
378. }
     
379. 
     
380. void delay_us( uchar i)   //执行次函数延时（ i+1） us ，注：此函数i最小取值为1 ，且不能改变为其它数据类型，所以此函数最大延时为256us。 (相当精确）
     
381. {
     
382. 
     
383.         do
     
384.         {
     
385.                 _nop_();
     
386.                 _nop_();
     
387.                 _nop_();
     
388.                 _nop_();
     
389.                 _nop_();
     
390.                 _nop_();
     
391.                 _nop_();
     
392.                 _nop_();
     
393.                 _nop_();
     
394.                 _nop_();
     
395.                 _nop_();
     
396.                 _nop_();
     
397.                 _nop_();
     
398.                 _nop_();
     
399.                 _nop_();
     
400.                 _nop_();
     
401.                 _nop_();
     
402.                 _nop_();
     
403.                 _nop_();
     
404.                 _nop_();
     
405.                 _nop_();
     
406.                 _nop_();  
     
407.         }
     
408.         while(--i);
     
409. 
     
410. }
     
411. 
     
412. /**********************************************************************************
     
413. 名称：LED显示屏驱动函数
     
414. 输入：i 为显示数据，j 为显示区域地址
     
415.                 j |            0     |      1     |     2     |      3     |     4     |     5     |     6     |      7     |      8      |     9      |
     
416.         ------|-----------|------------|-----------|------------|-----------|-----------|-----------|------------|-------------|------------|
     
417.                   |         数码管1  |         数码管2   |  数码管3  |   数码管4  |  数码管5  |  数码管6  |  数码管7  |  量程标识  |  量程标识   |  档位标识        |
     
418.         ------|-----------|------------|-----------|------------|-----------|-----------|-----------|------------|-------------|------------|
     
419.                  
     
420.        
     
421.        
     
422. *********************************************************************************/
     
423. void LED_display(uchar i,uchar j)
     
424. {
     
425.         switch(j)
     
426.         {
     
427.                 case 0:
     
428.                         P2=i;
     
429.                         P4=0x00;
     
430.                         delay_us(10);
     
431.                         P4=0xff;
     
432.                         break;
     
433.                 case 1:
     
434.                         P2=i;
     
435.                         P4=0x20;
     
436.                         delay_us(10);
     
437.                         P4=0xff;
     
438.                         break;
     
439.                 case 2:
     
440.                         P2=i;
     
441.                         P4=0x02;
     
442.                         delay_us(10);
     
443.                         P4=0xff;
     
444.                         break;
     
445.                 case 3:
     
446.                         P2=i;
     
447.                         P4=0x22;
     
448.                         delay_us(10);
     
449.                         P4=0xff;
     
450.                         break;
     
451.                                
     
452.                 case 4:
     
453.                         P2=i;
     
454.                         P4=0x04;
     
455.                         delay_us(10);
     
456.                         P4=0xff;
     
457.                         break;
     
458.                 case 5:
     
459.                         P2=i;
     
460.                         P4=0x24;
     
461.                         delay_us(10);
     
462.                         P4=0xff;
     
463.                         break;
     
464.                 case 6:
     
465.                         P2=i;
     
466.                         P4=0x06;
     
467.                         delay_us(10);
     
468.                         P4=0xff;
     
469.                         break;
     
470.                 case 7:
     
471.                         P2=i;
     
472.                         P4=0x26;
     
473.                         delay_us(10);
     
474.                         P4=0xff;
     
475.                         break;
     
476.                 case 8:
     
477.                         P2=i;
     
478.                         P4=0x10;
     
479.                         delay_us(10);
     
480.                         P4=0xff;
     
481.                         break;
     
482.                 case 9:
     
483.                         P2=i;
     
484.                         P4=0x30;
     
485.                         delay_us(10);
     
486.                         P4=0xff;
     
487.                         break;
     
488.                                                                                        
     
489.         }
     
490. }
     
491. 
     
492. void welcome()
     
493. {
     
494.         LED_display(0xff,0);
     
495.         LED_display(0x89,1);
     
496.         LED_display(0x86,2);
     
497.         LED_display(0xc7,3);
     
498.         LED_display(0xc7,4);
     
499.         LED_display(0xc0,5);
     
500.         LED_display(0xff,6);       
     
501. }
     
502. 
     
503. void AUTO_ZERO()
     
504. {
     
505.         uchar PP1;
     
506.         PP1=P1;
     
507.         P1=P1&0xf0;
     
508.         P1=P1|0x03;
     
509.         LE2=1;
     
510.         delay_us(10);
     
511.         LE2=0;
     
512.         delay_ms(5);
     
513.         ZERO=get_v();
     
514.                 ZERO=ZERO-33554432;               
     
515.         P1=PP1;
     
516.         LE2=1;
     
517.         delay_us(10);
     
518.         LE2=0;
     
519.         delay_ms(5);
     
520. }
     
521. void T0_int() interrupt 1
     
522. {       
     
523.         num++;
     
524.         if(num==50)
     
525.         {
     
526.                 num=0;
     
527.                 n++;
     
528.                 if(n==4)
     
529.                         n=0;
     
530.         }
     
531.        
     
532. }
     
533. 
     
534. 
     

复制代码

其实不想走

由于时间太紧程序只写了表能测量的最基本功能，还很不完善，待后续逐渐完善。且本人水平有限，有写得不妥的地方往各位老师多多指点。

gslimr

高手在民间，支持业余的一下哦。