标题: AD7799的单片机驱动程序（带详细注释,完全测试通过） [打印本页]

---

作者: zzuli_lulu    时间: 2018-11-25 14:49
标题: AD7799的单片机驱动程序（带详细注释,完全测试通过）
        本程序由《郑州轻工业大学》星空总创空间327房间鲁路编写,仅限于学习使用,如有问题,请联系:
        QQ:1224595453
        TEL:13071067331
        
        程序使用说明：
                1、Display包中是用与LCD1602显示的相关函数，使用只需重新定义LCD1602.h中的变量或者端口;
                2、Delay包中是相关延时函数;
                3、Main包中包括了实验板上的端口声明，以及菜单显示函数;
                4、AD7799包中是所有对AD7799的配置函数，每次使用时修改下面两个函数即可基本上配置所有AD7799的相关参数;
                        /*---------- AD7799修改单双极性增益倍数和通道 ----------*/
                        void AD7799_Set_Gain_and_Channel(uchar Polarity,uchar Gain,uchar Ch);        //Polarity为0代表双极性，为1代表单极性
        
                        /*---------- AD7799修改转换模式和转换速率 ----------*/
                        void AD7799_Set_Conversion_mode_and_Time(uchar Conversion_mode,uchar Time);        //Conversion_mode为0代表连续转换，为1代表单次转换，Conversion_mode代表转换速率
                5、本程序并未包含滤波算法，如需使用，请自己另加;
                6、更多相关知识，请参考AD7799Datasheet，建议学习英文原版手册，中文翻译的手册存在错误。

        附注：
                1、实验发现，AD7799内部增益调节最好不要超过2倍，超过2倍后，读数偏差巨大，这里不知道是否是电路或者程序的问题还是AD7799的问题；
                2、转换速率不要过高，使用推荐的16.7Hz较好；
                3、至于转换模式是连续还是单次，可以根据实际应用来设置，这里总结一下发现：连续转换适合于制作电压表或者测量仪器使用，因为转换速度快；单次转换在每次转换完成后会进入Power Down模式，因此适合于低功耗场合，
                   例如温度、湿度等变化速度不快的参量。


单片机源程序如下:

1. #include <AD7799.h>
   
2. #include <intrins.h>
   
3. #include <main.h>
   
4. #define        uchar unsigned char
   
5. #define uint unsigned int
   
6. #define ulint unsigned long int
   
7. #define N 16
   
8. #define A 10   //限幅滤波的幅值波动
   
9. 
   
10. /*---------- AD初始化 ----------*/
    
11. void AD7799_init_1(void)        //AD7799初始化,通道3,增益1,速率120ms
    
12. {
    
13.         CS=0;
    
14.         delay10ms();
    
15.         
    
16.         AD7799_Set_Gain_and_Channel(1,1,3);                //单极性,Gain=1,CH=3
    
17.         Internal_Zero_Scale_Calibration();                //片内零刻度校准
    
18.         Internal_Full_Scale_Calibration();                //片内满刻度校准
    
19.         
    
20.         AD7799_Set_Conversion_mode_and_Time(1,120);        //单次转换,转换速率120ms
    
21.         
    
22.         //写通信寄存器，下一次为写配置寄存器
    
23. //        SPI_Write_Byte(0x10);
    
24. //        delay10ms();
    
25. //        //写配置寄存器选择增益，通道，缓冲    //1022
    
26. //        SPI_Write_Byte(0x00);          //单极选择位=1（000000H--FFFFFFH）    增益为1
    
27. //        SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
    
28. //                                                 //（22H）3通道为1级放大       （21H） 2通道 2级放大
    
29. //        delay10ms();
    
30.         
    
31. 
    
32. //        //写通信寄存器，下一次为写模式寄存器
    
33. //        SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
    
34. //        delay10ms();
    
35. //        //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
    
36. //        SPI_Write_Byte(0x20);        //单次转换
    
37. //        SPI_Write_Byte(0x0A);        //默认速率（120ms）
    
38. //        delay10ms();
    
39. 
    
40. }
    
41. 
    
42. /*---------- AD7799修改单双极性增益倍数和通道 ----------*/
    
43. void AD7799_Set_Gain_and_Channel(uchar Polarity,uchar Gain,uchar Ch)        //Polarity为0代表双极性，为1代表单极性
    
44. {
    
45.     if(Polarity==1)                        //为1代表单极性
    
46.     {
    
47.         if(Ch==1)
    
48.         {
    
49.             if(Gain==1)
    
50.             {
    
51.                 //写通信寄存器，下一次为写配置寄存器
    
52.                 SPI_Write_Byte(0x10);
    
53.                 delay10ms();
    
54.                 //写配置寄存器选择增益，通道，缓冲    //
    
55.                 SPI_Write_Byte(0x10);          //单极选择位=1（000000H--FFFFFFH）    增益为1
    
56.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
    
57.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
    
58.                 delay10ms();
    
59.                 return;
    
60.             }
    
61.             else if(Gain==2)
    
62.             {
    
63.                 //写通信寄存器，下一次为写配置寄存器
    
64.                 SPI_Write_Byte(0x10);
    
65.                 delay10ms();
    
66.                 //写配置寄存器选择增益，通道，缓冲    //
    
67.                 SPI_Write_Byte(0x11);          //单极选择位=1（000000H--FFFFFFH）    增益为2
    
68.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
    
69.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
    
70.                 delay10ms();
    
71.                 return;
    
72.             }
    
73.             else if(Gain==4)
    
74.             {
    
75.                 //写通信寄存器，下一次为写配置寄存器
    
76.                 SPI_Write_Byte(0x10);
    
77.                 delay10ms();
    
78.                 //写配置寄存器选择增益，通道，缓冲    //
    
79.                 SPI_Write_Byte(0x12);          //单极选择位=1（000000H--FFFFFFH）    增益为4
    
80.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
    
81.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
    
82.                 delay10ms();
    
83.                 return;
    
84.             }
    
85.             else if(Gain==8)
    
86.             {
    
87.                 //写通信寄存器，下一次为写配置寄存器
    
88.                 SPI_Write_Byte(0x10);
    
89.                 delay10ms();
    
90.                 //写配置寄存器选择增益，通道，缓冲    //
    
91.                 SPI_Write_Byte(0x13);          //单极选择位=1（000000H--FFFFFFH）    增益为8
    
92.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
    
93.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
    
94.                 delay10ms();
    
95.                 return;
    
96.             }
    
97.             else if(Gain==16)
    
98.             {
    
99.                 //写通信寄存器，下一次为写配置寄存器
    
100.                 SPI_Write_Byte(0x10);
     
101.                 delay10ms();
     
102.                 //写配置寄存器选择增益，通道，缓冲    //
     
103.                 SPI_Write_Byte(0x14);          //单极选择位=1（000000H--FFFFFFH）    增益为16
     
104.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
105.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
106.                 delay10ms();
     
107.                 return;
     
108.             }
     
109.             else if(Gain==32)
     
110.             {
     
111.                 //写通信寄存器，下一次为写配置寄存器
     
112.                 SPI_Write_Byte(0x10);
     
113.                 delay10ms();
     
114.                 //写配置寄存器选择增益，通道，缓冲    //
     
115.                 SPI_Write_Byte(0x15);          //单极选择位=1（000000H--FFFFFFH）    增益为32
     
116.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
117.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
118.                 delay10ms();
     
119.                 return;
     
120.             }
     
121.             else if(Gain==64)
     
122.             {
     
123.                 //写通信寄存器，下一次为写配置寄存器
     
124.                 SPI_Write_Byte(0x10);
     
125.                 delay10ms();
     
126.                 //写配置寄存器选择增益，通道，缓冲    //
     
127.                 SPI_Write_Byte(0x16);          //单极选择位=1（000000H--FFFFFFH）    增益为64
     
128.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
129.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
130.                 delay10ms();
     
131.                 return;
     
132.             }
     
133.             else if(Gain==128)
     
134.             {
     
135.                 //写通信寄存器，下一次为写配置寄存器
     
136.                 SPI_Write_Byte(0x10);
     
137.                 delay10ms();
     
138.                 //写配置寄存器选择增益，通道，缓冲    //
     
139.                 SPI_Write_Byte(0x17);          //单极选择位=1（000000H--FFFFFFH）    增益为128
     
140.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
141.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
142.                 delay10ms();
     
143.                 return;
     
144.             }
     
145.         }
     
146.         else if(Ch==2)
     
147.         {
     
148.             if(Gain==1)
     
149.             {
     
150.                 //写通信寄存器，下一次为写配置寄存器
     
151.                 SPI_Write_Byte(0x10);
     
152.                 delay10ms();
     
153.                 //写配置寄存器选择增益，通道，缓冲    //
     
154.                 SPI_Write_Byte(0x10);          //单极选择位=1（000000H--FFFFFFH）    增益为1
     
155.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
156.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
157.                 delay10ms();
     
158.                 return;
     
159.             }
     
160.             else if(Gain==2)
     
161.             {
     
162.                 //写通信寄存器，下一次为写配置寄存器
     
163.                 SPI_Write_Byte(0x10);
     
164.                 delay10ms();
     
165.                 //写配置寄存器选择增益，通道，缓冲    //
     
166.                 SPI_Write_Byte(0x11);          //单极选择位=1（000000H--FFFFFFH）    增益为2
     
167.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
168.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
169.                 delay10ms();
     
170.                 return;
     
171.             }
     
172.             else if(Gain==4)
     
173.             {
     
174.                 //写通信寄存器，下一次为写配置寄存器
     
175.                 SPI_Write_Byte(0x10);
     
176.                 delay10ms();
     
177.                 //写配置寄存器选择增益，通道，缓冲    //
     
178.                 SPI_Write_Byte(0x12);          //单极选择位=1（000000H--FFFFFFH）    增益为4
     
179.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
180.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
181.                 delay10ms();
     
182.                 return;
     
183.             }
     
184.             else if(Gain==8)
     
185.             {
     
186.                 //写通信寄存器，下一次为写配置寄存器
     
187.                 SPI_Write_Byte(0x10);
     
188.                 delay10ms();
     
189.                 //写配置寄存器选择增益，通道，缓冲    //
     
190.                 SPI_Write_Byte(0x13);          //单极选择位=1（000000H--FFFFFFH）    增益为8
     
191.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
192.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
193.                 delay10ms();
     
194.                 return;
     
195.             }
     
196.             else if(Gain==16)
     
197.             {
     
198.                 //写通信寄存器，下一次为写配置寄存器
     
199.                 SPI_Write_Byte(0x10);
     
200.                 delay10ms();
     
201.                 //写配置寄存器选择增益，通道，缓冲    //
     
202.                 SPI_Write_Byte(0x14);          //单极选择位=1（000000H--FFFFFFH）    增益为16
     
203.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
204.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
205.                 delay10ms();
     
206.                 return;
     
207.             }
     
208.             else if(Gain==32)
     
209.             {
     
210.                 //写通信寄存器，下一次为写配置寄存器
     
211.                 SPI_Write_Byte(0x10);
     
212.                 delay10ms();
     
213.                 //写配置寄存器选择增益，通道，缓冲    //
     
214.                 SPI_Write_Byte(0x15);          //单极选择位=1（000000H--FFFFFFH）    增益为32
     
215.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
216.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
217.                 delay10ms();
     
218.                 return;
     
219.             }
     
220.             else if(Gain==64)
     
221.             {
     
222.                 //写通信寄存器，下一次为写配置寄存器
     
223.                 SPI_Write_Byte(0x10);
     
224.                 delay10ms();
     
225.                 //写配置寄存器选择增益，通道，缓冲    //
     
226.                 SPI_Write_Byte(0x16);          //单极选择位=1（000000H--FFFFFFH）    增益为64
     
227.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
228.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
229.                 delay10ms();
     
230.                 return;
     
231.             }
     
232.             else if(Gain==128)
     
233.             {
     
234.                 //写通信寄存器，下一次为写配置寄存器
     
235.                 SPI_Write_Byte(0x10);
     
236.                 delay10ms();
     
237.                 //写配置寄存器选择增益，通道，缓冲    //
     
238.                 SPI_Write_Byte(0x17);          //单极选择位=1（000000H--FFFFFFH）    增益为128
     
239.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
240.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
241.                 delay10ms();
     
242.                 return;
     
243.             }
     
244.         }
     
245.         else if(Ch==3)
     
246.         {
     
247.             if(Gain==1)
     
248.             {
     
249.                 //写通信寄存器，下一次为写配置寄存器
     
250.                 SPI_Write_Byte(0x10);
     
251.                 delay10ms();
     
252.                 //写配置寄存器选择增益，通道，缓冲    //
     
253.                 SPI_Write_Byte(0x10);          //单极选择位=1（000000H--FFFFFFH）    增益为1
     
254.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
255.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
256.                 delay10ms();
     
257.                 return;
     
258.             }
     
259.             else if(Gain==2)
     
260.             {
     
261.                 //写通信寄存器，下一次为写配置寄存器
     
262.                 SPI_Write_Byte(0x10);
     
263.                 delay10ms();
     
264.                 //写配置寄存器选择增益，通道，缓冲    //
     
265.                 SPI_Write_Byte(0x11);          //单极选择位=1（000000H--FFFFFFH）    增益为2
     
266.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
267.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
268.                 delay10ms();
     
269.                 return;
     
270.             }
     
271.             else if(Gain==4)
     
272.             {
     
273.                 //写通信寄存器，下一次为写配置寄存器
     
274.                 SPI_Write_Byte(0x10);
     
275.                 delay10ms();
     
276.                 //写配置寄存器选择增益，通道，缓冲    //
     
277.                 SPI_Write_Byte(0x12);          //单极选择位=1（000000H--FFFFFFH）    增益为4
     
278.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
279.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
280.                 delay10ms();
     
281.                 return;
     
282.             }
     
283.             else if(Gain==8)
     
284.             {
     
285.                 //写通信寄存器，下一次为写配置寄存器
     
286.                 SPI_Write_Byte(0x10);
     
287.                 delay10ms();
     
288.                 //写配置寄存器选择增益，通道，缓冲    //
     
289.                 SPI_Write_Byte(0x13);          //单极选择位=1（000000H--FFFFFFH）    增益为8
     
290.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
291.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
292.                 delay10ms();
     
293.                 return;
     
294.             }
     
295.             else if(Gain==16)
     
296.             {
     
297.                 //写通信寄存器，下一次为写配置寄存器
     
298.                 SPI_Write_Byte(0x10);
     
299.                 delay10ms();
     
300.                 //写配置寄存器选择增益，通道，缓冲    //
     
301.                 SPI_Write_Byte(0x14);          //单极选择位=1（000000H--FFFFFFH）    增益为16
     
302.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
303.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
304.                 delay10ms();
     
305.                 return;
     
306.             }
     
307.             else if(Gain==32)
     
308.             {
     
309.                 //写通信寄存器，下一次为写配置寄存器
     
310.                 SPI_Write_Byte(0x10);
     
311.                 delay10ms();
     
312.                 //写配置寄存器选择增益，通道，缓冲    //
     
313.                 SPI_Write_Byte(0x15);          //单极选择位=1（000000H--FFFFFFH）    增益为32
     
314.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
315.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
316.                 delay10ms();
     
317.                 return;
     
318.             }
     
319.             else if(Gain==64)
     
320.             {
     
321.                 //写通信寄存器，下一次为写配置寄存器
     
322.                 SPI_Write_Byte(0x10);
     
323.                 delay10ms();
     
324.                 //写配置寄存器选择增益，通道，缓冲    //
     
325.                 SPI_Write_Byte(0x16);          //单极选择位=1（000000H--FFFFFFH）    增益为64
     
326.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
327.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
328.                 delay10ms();
     
329.                 return;
     
330.             }
     
331.             else if(Gain==128)
     
332.             {
     
333.                 //写通信寄存器，下一次为写配置寄存器
     
334.                 SPI_Write_Byte(0x10);
     
335.                 delay10ms();
     
336.                 //写配置寄存器选择增益，通道，缓冲    //
     
337.                 SPI_Write_Byte(0x17);          //单极选择位=1（000000H--FFFFFFH）    增益为128
     
338.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
339.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
340.                 delay10ms();
     
341.                 return;
     
342.             }
     
343.         }
     
344.     }
     
345.     else if(Polarity==0)        //为0代表双极性
     
346.     {
     
347.         if(Ch==1)
     
348.         {
     
349.             if(Gain==1)
     
350.             {
     
351.                 //写通信寄存器，下一次为写配置寄存器
     
352.                 SPI_Write_Byte(0x10);
     
353.                 delay10ms();
     
354.                 //写配置寄存器选择增益，通道，缓冲    //
     
355.                 SPI_Write_Byte(0x00);          //双极选择位=0（000000H--FFFFFFH）    增益为1
     
356.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
357.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
358.                 delay10ms();
     
359.                 return;
     
360.             }
     
361.             else if(Gain==2)
     
362.             {
     
363.                 //写通信寄存器，下一次为写配置寄存器
     
364.                 SPI_Write_Byte(0x10);
     
365.                 delay10ms();
     
366.                 //写配置寄存器选择增益，通道，缓冲    //
     
367.                 SPI_Write_Byte(0x01);          //双极选择位=0（000000H--FFFFFFH）    增益为2
     
368.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
369.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
370.                 delay10ms();
     
371.                 return;
     
372.             }
     
373.             else if(Gain==4)
     
374.             {
     
375.                 //写通信寄存器，下一次为写配置寄存器
     
376.                 SPI_Write_Byte(0x10);
     
377.                 delay10ms();
     
378.                 //写配置寄存器选择增益，通道，缓冲    //
     
379.                 SPI_Write_Byte(0x02);          //双极选择位=0（000000H--FFFFFFH）    增益为4
     
380.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
381.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
382.                 delay10ms();
     
383.                 return;
     
384.             }
     
385.             else if(Gain==8)
     
386.             {
     
387.                 //写通信寄存器，下一次为写配置寄存器
     
388.                 SPI_Write_Byte(0x10);
     
389.                 delay10ms();
     
390.                 //写配置寄存器选择增益，通道，缓冲    //
     
391.                 SPI_Write_Byte(0x03);          //双极选择位=0（000000H--FFFFFFH）    增益为8
     
392.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
393.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
394.                 delay10ms();
     
395.                 return;
     
396.             }
     
397.             else if(Gain==16)
     
398.             {
     
399.                 //写通信寄存器，下一次为写配置寄存器
     
400.                 SPI_Write_Byte(0x10);
     
401.                 delay10ms();
     
402.                 //写配置寄存器选择增益，通道，缓冲    //
     
403.                 SPI_Write_Byte(0x04);          //双极选择位=0（000000H--FFFFFFH）    增益为16
     
404.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
405.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
406.                 delay10ms();
     
407.                 return;
     
408.             }
     
409.             else if(Gain==32)
     
410.             {
     
411.                 //写通信寄存器，下一次为写配置寄存器
     
412.                 SPI_Write_Byte(0x10);
     
413.                 delay10ms();
     
414.                 //写配置寄存器选择增益，通道，缓冲    //
     
415.                 SPI_Write_Byte(0x05);          //双极选择位=0（000000H--FFFFFFH）    增益为32
     
416.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
417.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
418.                 delay10ms();
     
419.                 return;
     
420.             }
     
421.             else if(Gain==64)
     
422.             {
     
423.                 //写通信寄存器，下一次为写配置寄存器
     
424.                 SPI_Write_Byte(0x10);
     
425.                 delay10ms();
     
426.                 //写配置寄存器选择增益，通道，缓冲    //
     
427.                 SPI_Write_Byte(0x06);          //双极选择位=0（000000H--FFFFFFH）    增益为64
     
428.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
429.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
430.                 delay10ms();
     
431.                 return;
     
432.             }
     
433.             else if(Gain==128)
     
434.             {
     
435.                 //写通信寄存器，下一次为写配置寄存器
     
436.                 SPI_Write_Byte(0x10);
     
437.                 delay10ms();
     
438.                 //写配置寄存器选择增益，通道，缓冲    //
     
439.                 SPI_Write_Byte(0x07);          //双极选择位=0（000000H--FFFFFFH）    增益为128
     
440.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
     
441.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
442.                 delay10ms();
     
443.                 return;
     
444.             }
     
445.         }
     
446.         else if(Ch==2)
     
447.         {
     
448.             if(Gain==1)
     
449.             {
     
450.                 //写通信寄存器，下一次为写配置寄存器
     
451.                 SPI_Write_Byte(0x10);
     
452.                 delay10ms();
     
453.                 //写配置寄存器选择增益，通道，缓冲    //
     
454.                 SPI_Write_Byte(0x00);          //双极选择位=0（000000H--FFFFFFH）    增益为1
     
455.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
456.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
457.                 delay10ms();
     
458.                 return;
     
459.             }
     
460.             else if(Gain==2)
     
461.             {
     
462.                 //写通信寄存器，下一次为写配置寄存器
     
463.                 SPI_Write_Byte(0x10);
     
464.                 delay10ms();
     
465.                 //写配置寄存器选择增益，通道，缓冲    //
     
466.                 SPI_Write_Byte(0x01);          //双极选择位=0（000000H--FFFFFFH）    增益为2
     
467.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
468.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
469.                 delay10ms();
     
470.                 return;
     
471.             }
     
472.             else if(Gain==4)
     
473.             {
     
474.                 //写通信寄存器，下一次为写配置寄存器
     
475.                 SPI_Write_Byte(0x10);
     
476.                 delay10ms();
     
477.                 //写配置寄存器选择增益，通道，缓冲    //
     
478.                 SPI_Write_Byte(0x02);          //双极选择位=0（000000H--FFFFFFH）    增益为4
     
479.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
480.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
481.                 delay10ms();
     
482.                 return;
     
483.             }
     
484.             else if(Gain==8)
     
485.             {
     
486.                 //写通信寄存器，下一次为写配置寄存器
     
487.                 SPI_Write_Byte(0x10);
     
488.                 delay10ms();
     
489.                 //写配置寄存器选择增益，通道，缓冲    //
     
490.                 SPI_Write_Byte(0x03);          //双极选择位=0（000000H--FFFFFFH）    增益为8
     
491.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
492.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
493.                 delay10ms();
     
494.                 return;
     
495.             }
     
496.             else if(Gain==16)
     
497.             {
     
498.                 //写通信寄存器，下一次为写配置寄存器
     
499.                 SPI_Write_Byte(0x10);
     
500.                 delay10ms();
     
501.                 //写配置寄存器选择增益，通道，缓冲    //
     
502.                 SPI_Write_Byte(0x04);          //双极选择位=0（000000H--FFFFFFH）    增益为16
     
503.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
504.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
505.                 delay10ms();
     
506.                 return;
     
507.             }
     
508.             else if(Gain==32)
     
509.             {
     
510.                 //写通信寄存器，下一次为写配置寄存器
     
511.                 SPI_Write_Byte(0x10);
     
512.                 delay10ms();
     
513.                 //写配置寄存器选择增益，通道，缓冲    //
     
514.                 SPI_Write_Byte(0x05);          //双极选择位=0（000000H--FFFFFFH）    增益为32
     
515.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
516.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
517.                 delay10ms();
     
518.                 return;
     
519.             }
     
520.             else if(Gain==64)
     
521.             {
     
522.                 //写通信寄存器，下一次为写配置寄存器
     
523.                 SPI_Write_Byte(0x10);
     
524.                 delay10ms();
     
525.                 //写配置寄存器选择增益，通道，缓冲    //
     
526.                 SPI_Write_Byte(0x06);          //双极选择位=0（000000H--FFFFFFH）    增益为64
     
527.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
528.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
529.                 delay10ms();
     
530.                 return;
     
531.             }
     
532.             else if(Gain==128)
     
533.             {
     
534.                 //写通信寄存器，下一次为写配置寄存器
     
535.                 SPI_Write_Byte(0x10);
     
536.                 delay10ms();
     
537.                 //写配置寄存器选择增益，通道，缓冲    //
     
538.                 SPI_Write_Byte(0x07);          //双极选择位=0（000000H--FFFFFFH）    增益为128
     
539.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
     
540.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
541.                 delay10ms();
     
542.                 return;
     
543.             }
     
544.         }
     
545.         else if(Ch==3)
     
546.         {
     
547.             if(Gain==1)
     
548.             {
     
549.                 //写通信寄存器，下一次为写配置寄存器
     
550.                 SPI_Write_Byte(0x10);
     
551.                 delay10ms();
     
552.                 //写配置寄存器选择增益，通道，缓冲    //
     
553.                 SPI_Write_Byte(0x00);          //双极选择位=0（000000H--FFFFFFH）    增益为1
     
554.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
555.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
556.                 delay10ms();
     
557.                 return;
     
558.             }
     
559.             else if(Gain==2)
     
560.             {
     
561.                 //写通信寄存器，下一次为写配置寄存器
     
562.                 SPI_Write_Byte(0x10);
     
563.                 delay10ms();
     
564.                 //写配置寄存器选择增益，通道，缓冲    //
     
565.                 SPI_Write_Byte(0x01);          //双极选择位=0（000000H--FFFFFFH）    增益为2
     
566.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
567.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
568.                 delay10ms();
     
569.                 return;
     
570.             }
     
571.             else if(Gain==4)
     
572.             {
     
573.                 //写通信寄存器，下一次为写配置寄存器
     
574.                 SPI_Write_Byte(0x10);
     
575.                 delay10ms();
     
576.                 //写配置寄存器选择增益，通道，缓冲    //
     
577.                 SPI_Write_Byte(0x02);          //双极选择位=0（000000H--FFFFFFH）    增益为4
     
578.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
579.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
580.                 delay10ms();
     
581.                 return;
     
582.             }
     
583.             else if(Gain==8)
     
584.             {
     
585.                 //写通信寄存器，下一次为写配置寄存器
     
586.                 SPI_Write_Byte(0x10);
     
587.                 delay10ms();
     
588.                 //写配置寄存器选择增益，通道，缓冲    //
     
589.                 SPI_Write_Byte(0x03);          //双极选择位=0（000000H--FFFFFFH）    增益为8
     
590.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
591.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
592.                 delay10ms();
     
593.                 return;
     
594.             }
     
595.             else if(Gain==16)
     
596.             {
     
597.                 //写通信寄存器，下一次为写配置寄存器
     
598.                 SPI_Write_Byte(0x10);
     
599.                 delay10ms();
     
600.                 //写配置寄存器选择增益，通道，缓冲    //
     
601.                 SPI_Write_Byte(0x04);          //双极选择位=0（000000H--FFFFFFH）    增益为16
     
602.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
603.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
604.                 delay10ms();
     
605.                 return;
     
606.             }
     
607.             else if(Gain==32)
     
608.             {
     
609.                 //写通信寄存器，下一次为写配置寄存器
     
610.                 SPI_Write_Byte(0x10);
     
611.                 delay10ms();
     
612.                 //写配置寄存器选择增益，通道，缓冲    //
     
613.                 SPI_Write_Byte(0x05);          //双极选择位=0（000000H--FFFFFFH）    增益为32
     
614.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
615.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
616.                 delay10ms();
     
617.                 return;
     
618.             }
     
619.             else if(Gain==64)
     
620.             {
     
621.                 //写通信寄存器，下一次为写配置寄存器
     
622.                 SPI_Write_Byte(0x10);
     
623.                 delay10ms();
     
624.                 //写配置寄存器选择增益，通道，缓冲    //
     
625.                 SPI_Write_Byte(0x06);          //双极选择位=0（000000H--FFFFFFH）    增益为64
     
626.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
627.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
628.                 delay10ms();
     
629.                 return;
     
630.             }
     
631.             else if(Gain==128)
     
632.             {
     
633.                 //写通信寄存器，下一次为写配置寄存器
     
634.                 SPI_Write_Byte(0x10);
     
635.                 delay10ms();
     
636.                 //写配置寄存器选择增益，通道，缓冲    //
     
637.                 SPI_Write_Byte(0x07);          //双极选择位=0（000000H--FFFFFFH）    增益为128
     
638.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
     
639.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
     
640.                 delay10ms();
     
641.                 return;
     
642.             }
     
643.         }
     
644.     }
     
645. }
     
646. 
     
647. /*---------- AD7799修改转换模式和转换速率 ----------*/
     
648. void AD7799_Set_Conversion_mode_and_Time(uchar Conversion_mode,uchar Time)        //Conversion_mode为0代表连续转换，为1代表单次转换，Conversion_mode代表转换速率
     
649. {
     
650.         if(Conversion_mode==0)                //Conversion_mode为0代表连续转换
     
651.         {
     
652.                 if(Time==4)                                //转换速率为4ms
     
653.                 {
     
654.                         //写通信寄存器，下一次为写模式寄存器
     
655.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
656.                         delay10ms();
     
657.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
658.                         SPI_Write_Byte(0x00);        //连续转换
     
659.                         SPI_Write_Byte(0x01);        //速率（4ms）
     
660.                         delay10ms();
     
661.                 }
     
662.                 else if(Time==8)                //转换速率为8ms
     
663.                 {
     
664.                         //写通信寄存器，下一次为写模式寄存器
     
665.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
666.                         delay10ms();
     
667.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
668.                         SPI_Write_Byte(0x00);        //连续转换
     
669.                         SPI_Write_Byte(0x02);        //速率（8ms）
     
670.                         delay10ms();
     
671.                 }
     
672.                 else if(Time==16)                //转换速率为16ms
     
673.                 {
     
674.                         //写通信寄存器，下一次为写模式寄存器
     
675.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
676.                         delay10ms();
     
677.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
678.                         SPI_Write_Byte(0x00);        //连续转换
     
679.                         SPI_Write_Byte(0x03);        //速率（16ms）
     
680.                         delay10ms();
     
681.                 }
     
682.                 else if(Time==32)                //转换速率为32ms
     
683.                 {
     
684.                         //写通信寄存器，下一次为写模式寄存器
     
685.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
686.                         delay10ms();
     
687.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
688.                         SPI_Write_Byte(0x00);        //连续转换
     
689.                         SPI_Write_Byte(0x04);        //速率（32ms）
     
690.                         delay10ms();
     
691.                 }
     
692.                 else if(Time==60)                //转换速率为60ms
     
693.                 {
     
694.                         //写通信寄存器，下一次为写模式寄存器
     
695.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
696.                         delay10ms();
     
697.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
698.                         SPI_Write_Byte(0x00);        //连续转换
     
699.                         SPI_Write_Byte(0x07);        //速率（60ms）
     
700.                         delay10ms();
     
701.                 }
     
702.                 else if(Time==120)                //转换速率为120ms
     
703.                 {
     
704.                         //写通信寄存器，下一次为写模式寄存器
     
705.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
706.                         delay10ms();
     
707.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
708.                         SPI_Write_Byte(0x00);        //连续转换
     
709.                         SPI_Write_Byte(0x0A);        //速率（120ms）
     
710.                         delay10ms();
     
711.                 }
     
712.                 else if(Time==200)                //转换速率为200ms
     
713.                 {
     
714.                         //写通信寄存器，下一次为写模式寄存器
     
715.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
716.                         delay10ms();
     
717.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
718.                         SPI_Write_Byte(0x00);        //连续转换
     
719.                         SPI_Write_Byte(0x0C);        //速率（200ms）
     
720.                         delay10ms();
     
721.                 }
     
722.                 else if(Time==480)                //转换速率为480ms
     
723.                 {
     
724.                         //写通信寄存器，下一次为写模式寄存器
     
725.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
726.                         delay10ms();
     
727.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
728.                         SPI_Write_Byte(0x00);        //连续转换
     
729.                         SPI_Write_Byte(0x0F);        //速率（480ms）
     
730.                         delay10ms();
     
731.                 }
     
732.         }
     
733.         else if(Conversion_mode==1)                //Conversion_mode为1代表单次转换
     
734.         {
     
735.                 if(Time==4)                                //转换速率为4ms
     
736.                 {
     
737.                         //写通信寄存器，下一次为写模式寄存器
     
738.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
739.                         delay10ms();
     
740.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
741.                         SPI_Write_Byte(0x20);        //单次转换
     
742.                         SPI_Write_Byte(0x01);        //速率（4ms）
     
743.                         delay10ms();
     
744.                 }
     
745.                 else if(Time==8)                //转换速率为8ms
     
746.                 {
     
747.                         //写通信寄存器，下一次为写模式寄存器
     
748.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
749.                         delay10ms();
     
750.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
751.                         SPI_Write_Byte(0x20);        //单次转换
     
752.                         SPI_Write_Byte(0x02);        //速率（8ms）
     
753.                         delay10ms();
     
754.                 }
     
755.                 else if(Time==16)                //转换速率为16ms
     
756.                 {
     
757.                         //写通信寄存器，下一次为写模式寄存器
     
758.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
759.                         delay10ms();
     
760.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
761.                         SPI_Write_Byte(0x20);        //单次转换
     
762.                         SPI_Write_Byte(0x03);        //速率（16ms）
     
763.                         delay10ms();
     
764.                 }
     
765.                 else if(Time==32)                //转换速率为32ms
     
766.                 {
     
767.                         //写通信寄存器，下一次为写模式寄存器
     
768.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
769.                         delay10ms();
     
770.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
771.                         SPI_Write_Byte(0x20);        //单次转换
     
772.                         SPI_Write_Byte(0x04);        //速率（32ms）
     
773.                         delay10ms();
     
774.                 }
     
775.                 else if(Time==60)                //转换速率为60ms
     
776.                 {
     
777.                         //写通信寄存器，下一次为写模式寄存器
     
778.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
779.                         delay10ms();
     
780.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
781.                         SPI_Write_Byte(0x20);        //单次转换
     
782.                         SPI_Write_Byte(0x07);        //速率（60ms）
     
783.                         delay10ms();
     
784.                 }
     
785.                 else if(Time==120)                //转换速率为120ms
     
786.                 {
     
787.                         //写通信寄存器，下一次为写模式寄存器
     
788.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
789.                         delay10ms();
     
790.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
791.                         SPI_Write_Byte(0x20);        //单次转换
     
792.                         SPI_Write_Byte(0x0A);        //速率（120ms）
     
793.                         delay10ms();
     
794.                 }
     
795.                 else if(Time==200)                //转换速率为200ms
     
796.                 {
     
797.                         //写通信寄存器，下一次为写模式寄存器
     
798.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
799.                         delay10ms();
     
800.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
801.                         SPI_Write_Byte(0x20);        //单次转换
     
802.                         SPI_Write_Byte(0x0C);        //速率（200ms）
     
803.                         delay10ms();
     
804.                 }
     
805.                 else if(Time==480)                //转换速率为480ms
     
806.                 {
     
807.                         //写通信寄存器，下一次为写模式寄存器
     
808.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
809.                         delay10ms();
     
810.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
811.                         SPI_Write_Byte(0x20);        //单次转换
     
812.                         SPI_Write_Byte(0x0F);        //速率（480ms）
     
813.                         delay10ms();
     
814.                 }
     
815.         }
     
816. }
     
817. 
     
818. /*---------- SPI写函数        ----------*/
     
819. void SPI_Write_Byte(uchar Data)
     
820. {
     
821.         uchar i;
     
822.         for(i=0;i<8;i++)
     
823.         {
     
824.                 clk=0;
     
825.                 if(Data&0x80) DIN=1;
     
826.                 else DIN=0;
     
827.                 Data=Data<<1;
     
828.                 delay1ms();
     
829.                 clk=1;
     
830.                 delay1ms();
     
831.         }
     
832. }
     
833. 
     
834. /*---------- AD7799复位        ----------*/
     
835. void AD7799_Reset(void)
     
836. {
     
837.         SPI_Write_Byte(0xff);
     
838.         SPI_Write_Byte(0xff);
     
839.         SPI_Write_Byte(0xff);
     
840.         SPI_Write_Byte(0xff);
     
841.         AD7799_init_1();                //初始化
     
842.         LED=1;                                        //灯灭
     
843. }
     
844. 
     
845. /*---------- 等待7799转换完成，看是否有错误        ----------*/
     
846. uchar Waite_DOUT(void)
     
847. {
     
848.         uchar i;
     
849.         unsigned int count=0;
     
850.         while(DOUT)
     
851.         {        
     
852.                 count++;
     
853.                 if(count>10000)
     
854.                 {
     
855.                         //灯亮
     
856.                         LED=0;        
     
857.                         while(i--)
     
858.                                 delay10ms();
     
859.                         return 0;
     
860.                 }
     
861.         }
     
862.         return 1;
     
863. }
     
864. 
     
865. /*这两个函数是标准推荐程序，用于以后项目用，此处只是列写并不使用  (始)  */
     
866. /*---------- AD单次转换及读取函数 ----------*/
     
867. unsigned long Single_Conversion_and_Read_AD(void)        //单次转换及读取函数
     
868. {
     
869.         //写通信寄存器，下一次为写模式寄存器
     
870.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
871.         delay10ms();
     
872.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
873.         SPI_Write_Byte(0x20);        //单次转换
     
874.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
     
875.         delay10ms();
     
876.         return Read_AD_Value();
     
877. }
     
878. 
     
879. /*---------- AD连续转换及读取函数 ----------*/
     
880. unsigned long Continuous_Conversion_and_Read_AD(void)        //连续转换及读取函数，以后使用只需调用        Read_AD_Value();        函数即可返回AD值
     
881. {
     
882.         //写通信寄存器，下一次为写模式寄存器
     
883.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
884.         delay10ms();
     
885.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
886.         SPI_Write_Byte(0x00);        //连续转换
     
887.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
     
888.         delay10ms();
     
889.         //以后使用只需调用        Read_AD_Value();        函数即可返回AD值
     
890.         return Read_AD_Value();
     
891. }
     
892. /*这两个函数是标准推荐程序，用于以后项目用，此处只是列写并不使用  (终)  */
     
893. 
     
894. /*---------- 从AD获取一次数据 ----------*/
     
895. unsigned long Read_AD_Value(void)
     
896. {
     
897.     unsigned long get_data=0;
     
898.         uchar i;
     
899.         
     
900.         if(Waite_DOUT()==0)                //查看是否超时
     
901.         {
     
902.                 //reset ad7799
     
903.                 /*---------- 防止时序混乱，重新同步        ----------*/
     
904.                 AD7799_Reset();
     
905.                 return 0;                        //超时退出读函数
     
906.         }
     
907.         else
     
908.         {
     
909.                 SPI_Write_Byte(0x58);        //发送读操作指令，读数据寄存器
     
910.                 delay1ms();
     
911.                
     
912.                 clk=1;
     
913.                 delay1ms();
     
914.                 //读数据
     
915.                 for(i=0;i<24;i++)         //第一次进入本函数，就是下降沿
     
916.                 {
     
917.                         delay1ms();
     
918.                         clk=0;
     
919.                         
     
920.                         get_data=get_data<<1;        
     
921.                         if(DOUT)
     
922.                                 get_data+=1;                                
     
923.                         clk=1;                        
     
924.                 }
     
925. //                for(i=0;i<8;i++)
     
926. //                {
     
927. //                        delay1ms();
     
928. //                        clk=0;
     
929. //                        delay1ms();
     
930. //                        clk=1;
     
931. //                }
     
932.                 DOUT=1;
     
933.                 return get_data;
     
934.         }
     
935. }
     
936. 
     
937. void Internal_Zero_Scale_Calibration(void)                //片内零刻度校准
     
938. {
     
939.         //写通信寄存器，下一次为写模式寄存器
     
940.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
941.         delay10ms();
     
942.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
943.         SPI_Write_Byte(0x80);        //内部零刻度校准模式
     
944.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
     
945.         delay10ms();
     
946.         Waite_DOUT();                        //等待零刻度校准完成
     
947. }
     
948. 
     
949. void Internal_Full_Scale_Calibration(void)                //片内满刻度校准
     
950. {
     
951.         //写通信寄存器，下一次为写模式寄存器
     
952.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
     
953.         delay10ms();
     
954.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
     
955.         SPI_Write_Byte(0xA0);        //内部慢刻度校准模式
     
956.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
     
957.         delay10ms();
     
958.         Waite_DOUT();                        //等待满刻度校准完成
     
959. }        
     
960. 
     
961. 
     
962. /**************************************
     
963.   名称：display100num
     
964.   功能：将24位数据转化为对应的ASCII码并在1602显示
     
965.   输入参数：输入000-FFFF的任意一个数
     
966.   输出参数： 对应的ASCII给1602显示
     
967. *************************************/
     
968. void display100num(unsigned long num)
     
969. {
     
970.         uchar a,b,c,d,e,f,g,h;
     
971. /*显示电压的变量*/        
     
972. //        float s;
     
973. //        long vv;
     
974. /*显示电压的变量*/        
     
975.         uchar i,j,k,l,m,n;
     
976.          
     
977.         a=num/10000000;                        //
     
978.         b=(num/1000000)%10;                //
     
979.         c=(num/100000)%10;                //
     
980.         d=(num/10000)%10;                //
     
981.         e=(num/1000)%10;                //
     
982.         f=(num/100)%10;                        //
     
983.         g=(num/10)%10;                        //
     
984.         h=num%10;                                //
     
985.         
     
986.         n=num%16;
     
987.         m=(num/16)%16;
     
988.         l=(num/16/16)%16;
     
989.         k=(num/16/16/16)%16;
     
990.         j=(num/16/16/16/16)%16;
     
991.         i=(num/16/16/16/16/16)%16;
     
992. 
     
993.         LCD1602_WriteCom(0xC0);         //10进制的AD值显示在第二行         
     
994.         LCD1602_WriteData(0x30+a);                        
     
995.         LCD1602_WriteData(0x30+b);
     
996.         LCD1602_WriteData(0x30+c);
     
997.         LCD1602_WriteData(0x30+d);
     
998.         LCD1602_WriteData(0x30+e);
     
999.         LCD1602_WriteData(0x30+f);
     
1000.         LCD1602_WriteData(0x30+g);
      
1001.         LCD1602_WriteData(0x30+h);
      
1002.         
      
1003. /*显示电压的函数*/        
      
1004. //        s=((num*4.9869f)/16777215.0f);  //电压转换   
      
1005. //        s*=10000.0f;
      
1006. //        vv=(unsigned long)s;         
      
1007. //        LCD1602_WriteCom(0xCA);   //显示在第二行        显示的电压
      
1008. //        LCD1602_WriteData(0x30+(vv/10000));
      
1009. //        LCD1602_WriteData('.');        
      
1010. //        LCD1602_WriteData(0x30+(vv/1000%10));                          
      
1011. //        LCD1602_WriteData(0x30+(vv/100%10));
      
1012. //        LCD1602_WriteData(0x30+(vv/10%10));
      
1013. //        LCD1602_WriteData(0x30+(vv%10));
      
1014. //        LCD1602_WriteData('V');      
      
1015. /*显示电压的函数*/        
      
1016.         
      
1017.         LCD1602_WriteCom(0xCA);   //16进制的AD值显示在第二行
      
1018.         LCD1602_WriteData(LCD1602_HEX_to_ASC(i));
      
1019.         LCD1602_WriteData(LCD1602_HEX_to_ASC(j));
      
1020.         LCD1602_WriteData(LCD1602_HEX_to_ASC(k));
      
1021.         LCD1602_WriteData(LCD1602_HEX_to_ASC(l));
      
1022.         LCD1602_WriteData(LCD1602_HEX_to_ASC(m));
      
1023.         LCD1602_WriteData(LCD1602_HEX_to_ASC(n));
      
1024. }
      
1025. 
      
1026. //延时函数
      
1027. void delay10ms(void)   //误差 0us
      
1028. {
      
1029.     unsigned char a,b,c;
      
1030.     for(c=5;c>0;c--)
      
1031.         for(b=4;b>0;b--)
      
1032.             for(a=248;a>0;a--);
      
1033. }
      
1034. 
      
1035. void delay1ms(void)   //误差 0us
      
1036. {
      
1037.     unsigned char a,b;
      
1038.     for(b=199;b>0;b--)
      
1039.         for(a=1;a>0;a--);
      
1040. }
      

复制代码

主程序：

1. #include <main.h>
   
2. 
   
3. uchar code str1[]=" Welcome to use ";
   
4. uchar code str2[]="AD7799 Board 509";
   
5. 
   
6. uchar Q_Menu=0;                                //全局变量-菜单号
   
7. uchar Q_Channel=0;                        //全局变量-模拟通道(取值1,2,3)
   
8. uchar Q_Gain_ADC=0;                        //全局变量-通道增益(最大128,不超过256,用uchar类型)
   
9. uint  Q_Time_Settle=0;                //全局变量-转换时间(因为最大480,超过256,故用uint类型)
   
10. uchar Q_Polarity=0;                        //全局变量-转换极性(1单极性 0双极性)
    
11. uchar Q_Conversion_mode=0;        //全局变量-连续单次模式(1单次转换 0连续转换)
    
12. uchar Q_enable_Conversion=0;//是否可以转换标志,为1代表可以转换,为0代表当前正在设置功能不能转换
    
13. 
    
14. void main(void)
    
15. {
    
16.         
    
17.         LCD1602_Init();                                //LCD1602初始化程序
    
18.         LCD_Display_AnyStr(0x80,16,str1);                //位置  长度  指针
    
19.         LCD_Display_AnyStr(0xC0,16,str2);                //位置  长度  指针
    
20.         while(key1&&key2&&key3&&key4);                        //任意键继续
    
21.         LCD1602_WriteCom(0x01);          //清屏
    
22.         
    
23.         AD7799_init_1();                        //AD7799初始化,通道3,增益1,速率120ms  
    
24.         AD7799_Reset();                                //手动复位一次
    
25.         
    
26.         Q_Menu=0;
    
27.         Q_enable_Conversion=0;
    
28.         
    
29.         Q_Channel=3;
    
30.         Q_Gain_ADC=1;
    
31.         Q_Time_Settle=120;
    
32.         Q_Polarity=1;
    
33.         Q_Conversion_mode=1;
    
34. 
    
35.         
    
36.         Display_Menu_0();        //显示基础框架
    
37.         while(1)
    
38.         {
    
39.                
    
40.                 if(Check_key1())                //检测设置功能键是否长按
    
41.                 {
    
42.                         Display_Menu_1();        //当前显示指向CHx
    
43.                         Q_Menu=1;
    
44.                         
    
45.                         Q_enable_Conversion=0;                        //如果有按键触发,将Q_enable_Conversion置0,代表正在设置
    
46.                         //再次检测是否抖动并且
    
47.                         while(!Q_enable_Conversion)                //当还未按OK时,不能跳出while,只有按了OK,可以跳出本循环,执行显示数值
    
48.                         {
    
49.                                 Display_Menu(Judge_Key());
    
50.                         }
    
51.                 }
    
52.                 else        //没有检测到按键
    
53.                 {
    
54.                         if(Q_Conversion_mode==1)        //为1代表当前是单次转换，用单次转换的读取函数
    
55.                         {
    
56.                                 //更新显示AD值及配置信息
    
57.                                 Display_AD((float)Single_Conversion_and_Read_AD());                //更新显示AD值及配置信息
    
58.                         }
    
59.                         if(Q_Conversion_mode==0)        //为0代表当前是连续转换，用连续转换的读取函数
    
60.                         {
    
61.                                 Display_AD((float)Read_AD_Value());
    
62.                         }
    
63.                 }
    
64.         }
    
65. }
    
66. 
    
67. uchar Check_key1(void)                        //检测设置功能键是否长按
    
68. {
    
69.         uint i=0;
    
70.         while(!key1)                //按下了
    
71.         {
    
72.                 i++;                        //累加按下时间
    
73.                 if(i>=40000)        //时间如果足够,则返回1
    
74.                 {
    
75.                         LED=0;                        //点亮
    
76.                         return 1;
    
77.                 }
    
78.         }
    
79.         return 0;                        //若按下时间不够或者没按,返回0
    
80. }
    
81. 
    
82. uchar Judge_Key(void)                //判键程序
    
83. {
    
84.         if(!key1)
    
85.         {
    
86.                 delay10ms_12M();        //10ms效抖
    
87.                 if(!key1)
    
88.                 {
    
89.                         while(!key1);
    
90.                         return 1;                //按key1
    
91.                 }
    
92.         }
    
93.         else if(!key2)
    
94.         {
    
95.                 delay10ms_12M();        //10ms效抖
    
96.                 if(!key2)
    
97.                 {
    
98.                         while(!key2);
    
99.                         return 2;                //按key2
    
100.                 }
     
101.         }
     
102.         else if(!key3)
     
103.         {
     
104.                 delay10ms_12M();        //10ms效抖
     
105.                 if(!key3)
     
106.                 {
     
107.                         while(!key3);
     
108.                         return 3;                //按key3
     
109.                 }
     
110.         }
     
111.         else if(!key4)
     
112.         {
     
113.                 delay10ms_12M();        //10ms效抖
     
114.                 if(!key4)
     
115.                 {
     
116.                         while(!key4);
     
117.                         return 4;                //按key4
     
118.                 }
     
119.         }
     
120.         return 0;                                //未按键或者是抖动
     
121. }
     
122. 
     
123. void Display_Menu(uchar key_Value)                //根据当前界面和按键号显示菜单内容
     
124. {
     
125.         if(key_Value==0)        //如果未按或者抖动直接退出
     
126.         {
     
127.                 return;
     
128.         }
     
129.         Q_enable_Conversion=0;        //为0代表正在设置功能,禁止显示
     
130.         
     
131.         switch (Q_Menu)                //判断当前菜单
     
132.         {
     
133.                 case 0:                //AD结果及设置显示界面
     
134.                 {
     
135.                         if(key_Value==1)
     
136.                         {
     
137.                                 Display_Menu_1();        //当前显示指向CHx
     
138.                                 Q_Menu=1;
     
139.                         }
     
140.                         else if(key_Value==4)
     
141.                         {
     
142.                                 //fuwei
     
143.                         }
     
144.                         break;
     
145.                 }
     
146.                 case 1:                //当前显示指向CHx
     
147.                 {
     
148.                         if(key_Value==1)
     
149.                         {
     
150.                                 //fanhui
     
151.                         }
     
152.                         else if(key_Value==2)
     
153.                         {
     
154.                                 
     
155. ……………………
     
156. 
     
157. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
AD7799程序C51.zip (125.19 KB, 下载次数: 140)

2018-11-25 14:47 上传

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

---

作者: 15158296    时间: 2020-4-15 15:34
谢谢，正在找这个代码

---

作者: zbfdyw    时间: 2020-4-16 11:11
感谢您这么辛苦的整理资料，我在这里向您致敬！

---

作者: randy619    时间: 2020-5-20 18:35
太感谢楼主了

---

作者: mgchhxd    时间: 2025-3-11 17:16
感谢，很有帮助，不用自己挨个对寄存器了。

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1