代码:

1. #include "reg52.h"
   
2. 
   
3. //宏定义
   
4. #define uchar unsigned char
   
5. #define uint  unsigned int
   
6. 
   
7. //按键定义
   
8. sbit KEY1= P3^7;
   
9. sbit KEY2= P3^6;
   
10. sbit KEY3= P3^5;
    
11. sbit KEY4= P3^4;
    
12. 
    
13. //数码管定义
    
14. sbit W1= P2^6;
    
15. sbit W2= P2^4;
    
16. sbit W3= P2^2;
    
17. sbit W4= P2^0;
    
18. 
    
19. //DAC定义
    
20. sbit  CS_5615=P1^5;
    
21. sbit CLK_5615=P1^6;
    
22. sbit DAT_5615=P1^7;
    
23. 
    
24. //ADC定义
    
25. sbit  CS=P1^2;      
    
26. sbit CLK=P1^1;      
    
27. sbit DIO=P1^0;
    
28.   
    
29. uint  U;
    
30. uchar GETU=0;
    
31. bit flag=0;
    
32. uint  a=0;
    
33. 
    
34. uchar code table[]=
    
35. {
    
36.         0x5F,0x44,0x9D,0xD5,0xC6,0xD3,0xDB,0x47,0xDF,0xD7
    
37. };        //共阳数码管段码表        没有小数点 0~9
    
38. uchar code table1[]=
    
39. {
    
40.         0x7F,0x64,0xBD,0xF5,0xE6,0xF3,0xFB,0x67,0xFF,0xF7,0x5e
    
41. };//带小数点的编码            0~9
    
42. 
    
43. 
    
44. void delay_ms(uint z)                          //延时函数
    
45. {
    
46.   uint a,b;
    
47.   for(a=z;a>0;a--)
    
48.    for(b=5;b>0;b--);
    
49. }
    
50. 
    
51. void  shuma(uint buf)
    
52. {
    
53.         uchar a,b,c,d;
    
54.         a=buf/1000;
    
55.         b=buf%1000/100;
    
56.         c=buf%100/10;
    
57.         d=buf%10;
    
58. 
    
59.         W1=0;W2=1;W3=1;W4=1;        
    
60.         P0=~table[a];
    
61.         delay_ms(60);
    
62. 
    
63.         W1=1;W2=0;W3=1;W4=1;
    
64.         P0=~table1[b];
    
65.         delay_ms(60);
    
66. 
    
67.         W1=1;W2=1;W3=0;W4=1;
    
68.         P0=~table[c];
    
69.         delay_ms(60);
    
70. 
    
71.         W1=1;W2=1;W3=1;W4=0;
    
72.         P0=~table1[10];
    
73.         delay_ms(60);
    
74. }
    
75. 
    
76. void tlc_5615(uint buf)
    
77. {
    
78.         uint a,c;
    
79.         c=buf;   
    
80.     CS_5615=0;
    
81.         for(a=16;a>0;a--)
    
82.         {
    
83.          DAT_5615=c>>15;      
    
84.          c=c<<1;
    
85.          CLK_5615=1;
    
86.          CLK_5615=0;                 
    
87.     }
    
88.         CLK_5615=1;
    
89.         CLK_5615=0;
    
90.         CLK_5615=1;
    
91.         CLK_5615=0;
    
92.         CS_5615=1;
    
93. }
    
94. 
    
95. unsigned int  A_D()
    
96. {
    
97.         unsigned char i,dat;
    
98.         CS=1;   //一个转换周期开始
    
99.         CLK=0;  //为第一个脉冲作准备
    
100.         CS=0;  //CS置0，片选有效
     
101.         
     
102.         DIO=1;    //DIO置1，规定的起始信号  
     
103.         CLK=1;   //第一个脉冲
     
104.         CLK=0;   //第一个脉冲的下降沿，此前DIO必须是高电平
     
105.         DIO=1;   //DIO置1， 通道选择信号  
     
106.         CLK=1;   //第二个脉冲，第2、3个脉冲下沉之前，DI必须跟别输入两位数据用于选择通道，这里选通道CH0
     
107.         CLK=0;   //第二个脉冲下降沿
     
108.         DIO=0;   //DI置0，选择通道0
     
109.         CLK=1;    //第三个脉冲
     
110.         CLK=0;    //第三个脉冲下降沿
     
111.         DIO=1;    //第三个脉冲下沉之后，输入端DIO失去作用，应置1
     
112.         CLK=1;    //第四个脉冲
     
113.         for(i=0;i<8;i++)  //高位在前
     
114.         {
     
115.                 CLK=1;         //第四个脉冲
     
116.                 CLK=0;
     
117.                 dat<<=1;       //将下面储存的低位数据向右移
     
118.                 dat|=(unsigned char)DIO;          //将输出数据DIO通过或运算储存在dat最低位
     
119.         }                                 
     
120.         CS=1;          //片选无效
     
121.         return dat;         //将读出的数据返回     
     
122. }
     
123. 
     
124. 
     
125. //主函数
     
126. void main(void)
     
127. {
     
128.         U=0;
     
129.         while(1)
     
130.         {
     
131.                 tlc_5615(U);
     
132.                 shuma(U/8*10);
     
133.                 if(flag==0)
     
134.                 {
     
135.                         if(KEY1==0)
     
136.                         {
     
137.                                 shuma(U/8*10);
     
138.                                 shuma(U/8*10);
     
139.                                 shuma(U/8*10);
     
140.                                 shuma(U/8*10);
     
141.                                 shuma(U/8*10);
     
142.                                 if(KEY1==0)
     
143.                                 {
     
144.                                         if(U<960)        //1V对应的是80  10位ad
     
145.                                         U=U+8;
     
146.                                 }        
     
147.                         }
     
148.                         if(KEY2==0)
     
149.                         {
     
150.                                 shuma(U/8*10);
     
151.                                 shuma(U/8*10);
     
152.                                 shuma(U/8*10);
     
153.                                 shuma(U/8*10);
     
154.                                 shuma(U/8*10);
     
155.                                 if(KEY2==0)
     
156.                                 {
     
157.                                         if(U>=8)
     
158.                                         U=U-8;
     
159.                                 }        
     
160.                         }                        
     
161.                         if(KEY3==0)
     
162.                         {
     
163.                                 shuma(U/8*10);
     
164.                                 shuma(U/8*10);
     
165.                                 shuma(U/8*10);
     
166.                                 shuma(U/8*10);
     
167.                                 shuma(U/8*10);
     
168.                                 if(KEY3==0)
     
169.                                 {
     
170.                                         U=400;        
     
171.                                 }        
     
172.                         }        
     
173.                         if(KEY4==0)
     
174.                         {
     
175.                                 shuma(U/8*10);
     
176.                                 shuma(U/8*10);
     
177.                                 shuma(U/8*10);
     
178.                                 shuma(U/8*10);
     
179.                                 shuma(U/8*10);
     
180.                                 if(KEY4==0)
     
181.                                 {
     
182.                                         U=0;
     
183.                                 }        
     
184.                         }
     
185.                 }
     
186.                 GETU=A_D();
     
187.                 if(GETU>=12)   //0.0196V
     
188.                 {
     
189.                         U=0;
     
190.                          a=0;
     
191.                         flag=1;
     
192.                 }                                
     
193.         }
     
194. }