基于PCF8591的模数与数模转换模块应用

jennyzhaojie

PCF8591是一个集成了模数与数模转换功能的芯片，该芯片共有16个引脚，并采用IIC总线接口与外部交换信息。

对于模数转换功能来说，它供提供4个模拟量采集通道，分别由AIN0~AIN3引脚来输入。而数模转换功能只提供了一个通道，由Aout引脚来输出。

PCF8591的数据引脚为SDA，时钟引脚为SCL。在使用时，可使用普通的IO来模拟产生。就控制流程来讲，该芯片在使用时共分四步：

1）发送地址字节（0x90），选择该器件。

2）发送控制字节，选择相应通道（0x40~0x43）。

3）重新发送地址字节，选择该器件。

4）接收目标通道的数据。

   模块的工作原理图如图1所示，其中的发光电阻可以指示Aout的输出电压，而在输入端AIN0处串接光敏二极管或热敏电阻的情况下，则可以检测亮度和温度信号。

图1 模块原理图

为便于对该模块进行检测，可以通过51单片机及光敏电阻与其构成一个检测电路，

模块与51单片机的连接关系如下：

    SCL -- P2.3;

    SDA -- P2.2;

检测程序的处理流程为AD采样、DA转换、串口发送，其执行效果如图2所示。

图2 执行效果

检测程序如下：

1. #include <reg52.h>
   
2. #include <51hei.h>
   
3. #include <intrins.h>
   
4. typedef unsigned char uint8;
   
5. typedef unsigned int uint16;
   
6. #define PCF8591 0x90
   
7. #define  NOP() _nop_()
   
8. #define _Nop() _nop_()
   
9. 
   
10. unsigned char AD_CHANNEL;
    
11. unsigned long xdata  Out[8];
    
12. unsigned int D[32];
    
13. 
    
14. sbit SCL = P2^3;
    
15. sbit SDA = P2^2;
    
16. bit ack;
    
17. 
    
18. void Start_I2c()
    
19. {
    
20. SDA=1;
    
21. _Nop();
    
22. SCL=1;
    
23. _Nop();  /*4.7us*/
    
24. _Nop();
    
25. _Nop();
    
26. _Nop();
    
27. _Nop();
    
28. SDA=0;
    
29. _Nop();
    
30. _Nop();
    
31. _Nop();
    
32. _Nop();
    
33. _Nop();
    
34. SCL=0;
    
35. _Nop();
    
36. _Nop();
    
37. }
    
38. 
    
39. void Stop_I2c()
    
40. {
    
41. SDA=0;
    
42. _Nop();
    
43. SCL=1;
    
44. _Nop();
    
45. _Nop();
    
46. _Nop();
    
47. _Nop();
    
48. _Nop();
    
49. SDA=1;
    
50. _Nop();
    
51. _Nop();
    
52. _Nop();
    
53. _Nop();
    
54. }
    
55. 
    
56. void SendByte(unsigned char c)
    
57. {
    
58. unsigned char BitCnt;
    
59. 
    
60. for(BitCnt=0;BitCnt<8;BitCnt++)
    
61. {
    
62. if((c<<BitCnt)&0x80) SDA=1;
    
63. else SDA=0;
    
64. _Nop();
    
65. SCL=1;
    
66. _Nop();
    
67. _Nop();
    
68. _Nop();
    
69. _Nop();
    
70. _Nop();
    
71. SCL=0;
    
72. }
    
73. _Nop();
    
74. _Nop();
    
75. SDA=1;
    
76. _Nop();
    
77. _Nop();
    
78. SCL=1;
    
79. _Nop();
    
80. _Nop();
    
81. _Nop();
    
82. if(SDA==1)ack=0;
    
83. else ack=1;
    
84. SCL=0;
    
85. _Nop();
    
86. _Nop();
    
87. }
    
88. 
    
89. unsigned char RcvByte()
    
90. {
    
91. unsigned char retc;
    
92. unsigned char BitCnt;
    
93. retc=0;
    
94. SDA=1;
    
95. for(BitCnt=0;BitCnt<8;BitCnt++)
    
96. {
    
97. _Nop();
    
98. SCL=0;
    
99. _Nop();
    
100. _Nop();
     
101. _Nop();
     
102. _Nop();
     
103. _Nop();
     
104. SCL=1;
     
105. _Nop();
     
106. _Nop();
     
107. retc=retc<<1;
     
108. if(SDA==1) retc=retc+1;
     
109. _Nop();
     
110. _Nop();
     
111. }
     
112. SCL=0;
     
113. _Nop();
     
114. _Nop();
     
115. return(retc);
     
116. }
     
117. 
     
118. void Ack_I2c(bit a)
     
119. {
     
120. if(a==0) SDA=0;
     
121. else SDA=1;
     
122. _Nop();
     
123. _Nop();
     
124. _Nop();
     
125. SCL=1;
     
126. _Nop();
     
127. _Nop();
     
128. _Nop();
     
129. _Nop();
     
130. _Nop();
     
131. SCL=0;
     
132. _Nop();
     
133. _Nop();
     
134. }
     
135. 
     
136. 
     
137. bit DACconversion(unsigned char sla,unsigned char c, unsigned char Val)
     
138. {
     
139. Start_I2c();
     
140. SendByte(sla);
     
141. if(ack==0)return(0);
     
142. SendByte(c);
     
143. if(ack==0)return(0);
     
144. SendByte(Val);
     
145. if(ack==0)return(0);
     
146. Stop_I2c();
     
147. return(1);
     
148. }
     
149. 
     
150. bit ISendByte(unsigned char sla,unsigned char c)
     
151. {
     
152. Start_I2c();
     
153. SendByte(sla);
     
154. if(ack==0) return(0);
     
155. SendByte(c);
     
156. if(ack==0) return(0);
     
157. Stop_I2c();
     
158. return(1);
     
159. }
     
160. 
     
161. unsigned char IRcvByte(unsigned char sla)
     
162. {
     
163. unsigned char c;
     
164. Start_I2c();
     
165. SendByte(sla+1);
     
166. if(ack==0)return(0);
     
167. c=RcvByte();
     
168. Ack_I2c(1);
     
169. Stop_I2c();
     
170. return(c);
     
171. }
     
172. 
     
173. void uart_init(void)
     
174. {
     
175. ET1=0;
     
176. TMOD = 0x21;
     
177. SCON = 0x50;
     
178. TH1 = 0xFD;     //    11.0592   9600bps
     
179. TL1 = 0xFD;
     
180. TR1 = 1;
     
181. }
     
182. 
     
183. void UART_Send_Byte(uint8 dat)
     
184. {
     
185. SBUF = dat;
     
186. while(TI == 0);
     
187. TI = 0;
     
188. }
     
189. 
     
190. void delay(uint16 n)
     
191. {
     
192.           while(n--);
     
193. }
     
194. void main()
     
195. {
     
196. char i,j;
     
197. uart_init();
     
198. while(1)
     
199. {
     
200. switch(AD_CHANNEL)
     
201. {
     
202. case 0: ISendByte(PCF8591,0x41);
     
203.         D[0]=IRcvByte(PCF8591)*2;  //ADC0  0~0xff  0~510 ( 5.1V )
     
204.         break;
     
205. case 1: ISendByte(PCF8591,0x42);
     
206.         D[1]=IRcvByte(PCF8591)*2;  //ADC1
     
207.         break;
     
208. case 2: ISendByte(PCF8591,0x43);
     
209.         D[2]=IRcvByte(PCF8591)*2;  //ADC2
     
210.         break;
     
211. case 3: ISendByte(PCF8591,0x40);
     
212.         D[3]=IRcvByte(PCF8591)*2;  //ADC3
     
213.         break;
     
214. case 4: DACconversion(PCF8591,0x40, 0xff);
     
215.       break;
     
216. }
     
217.         D[4]=D[3];
     
218. if(++AD_CHANNEL>4)   AD_CHANNEL=0;
     
219. 
     
220. Out[0]=D[0]%10000/1000;  
     
221. Out[1]=D[0]%1000/100;
     
222. Out[2]=D[0]%100/10;   
     
223. Out[3]=D[0]%10;
     
224. 
     
225. Out[4]=D[1]%10000/1000;  
     
226. Out[5]=D[1]%1000/100;
     
227. Out[6]=D[1]%100/10;   
     
228. Out[7]=D[1]%10;
     
229. 
     
230. UART_Send_Byte('A');
     
231. UART_Send_Byte('D');
     
232. UART_Send_Byte('C');       
     
233. UART_Send_Byte('0');
     
234. UART_Send_Byte(':');
     
235. 
     
236. for( i=0; i<4; i++)
     
237. {
     
238.    UART_Send_Byte(Out[i]+'0');
     
239. }
     
240. UART_Send_Byte(0X0D);
     
241. UART_Send_Byte(0X0A);
     
242. 
     
243. UART_Send_Byte('A');
     
244. UART_Send_Byte('D');
     
245. UART_Send_Byte('C');       
     
246. UART_Send_Byte('1');
     
247. UART_Send_Byte(':');
     
248. 
     
249. for( i=4; i<8; i++)
     
250. {
     
251.    UART_Send_Byte(Out[i]+'0');
     
252. }
     
253. UART_Send_Byte(0X0D);
     
254. UART_Send_Byte(0X0A);
     
255. 
     
256. Out[0]=D[2]%10000/1000;   
     
257. Out[1]=D[2]%1000/100;
     
258. Out[2]=D[2]%100/10;   
     
259. Out[3]=D[2]%10;
     
260. 
     
261. Out[4]=D[3]%10000/1000;   
     
262. Out[5]=D[3]%1000/100;
     
263. Out[6]=D[3]%100/10;   
     
264. Out[7]=D[3]%10;
     
265. 
     
266. UART_Send_Byte('A');
     
267. UART_Send_Byte('D');
     
268. UART_Send_Byte('C');       
     
269. UART_Send_Byte('2');
     
270. UART_Send_Byte(':');
     
271. 
     
272. for( i=0; i<4; i++)
     
273. {
     
274.    UART_Send_Byte(Out[i]+'0');         
     
275. }
     
276. UART_Send_Byte(0X0D);
     
277. UART_Send_Byte(0X0A);
     
278. 
     
279. UART_Send_Byte('A');
     
280. UART_Send_Byte('D');
     
281. UART_Send_Byte('C');       
     
282. UART_Send_Byte('3');
     
283. UART_Send_Byte(':');
     
284. 
     
285. for( i=4; i<8; i++)
     
286. {
     
287.    UART_Send_Byte(Out[i]+'0');
     
288. }
     
289. UART_Send_Byte(0X0D);
     
290. UART_Send_Byte(0X0A);
     
291. delay(50000);
     
292. }
     
293. }

复制代码