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

標題: 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://m.raoushi.com/bbs/)

Powered by Discuz! X3.1

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

1024手机基地看电影