代码:

1. #include "reg52.h"
   
2. #include <intrins.h>
   
3. 
   
4. #define unchar unsigned char
   
5. #define uint unsigned int
   
6. 
   
7. sbit scl=P2^1;
   
8. sbit sda=P2^0;
   
9. 
   
10. unchar dat[4]={'0','0','0','0'};
    
11. 
    
12. 
    
13. void delay_4us()
    
14. {
    
15.         _nop_();
    
16.         _nop_();
    
17.         _nop_();
    
18.         _nop_();
    
19.         
    
20. }
    
21. 
    
22. 
    
23. void delay(uint i)
    
24. {
    
25.         while(i--);
    
26. }
    
27. 
    
28. void i2c_init()
    
29. {
    
30.         scl=0;
    
31.         sda=1;
    
32.         delay_4us();
    
33.         scl=1;
    
34.         delay_4us();
    
35.         scl=0;
    
36. }
    
37. 
    
38. void i2c_start()
    
39. {
    
40.         scl=0;
    
41.         delay_4us();
    
42.         sda=1;
    
43.         delay_4us();
    
44.         scl=1;
    
45.         delay_4us();
    
46.         sda=0;
    
47.         delay_4us();
    
48.         scl=0;
    
49. }
    
50. 
    
51. 
    
52. void i2c_stop()
    
53. {
    
54.         scl=0;
    
55.         delay_4us();
    
56.         sda=0;
    
57.         delay_4us();
    
58.         scl=1;
    
59.         delay_4us();
    
60.         sda=1;
    
61.         delay_4us();
    
62.         scl=0;
    
63.         delay_4us();
    
64. }
    
65. 
    
66. 
    
67. void i2c_ack(unchar ackbit)
    
68. {
    
69.         if(!ackbit)
    
70.         {
    
71.                 sda=0;
    
72.         }
    
73.         else
    
74.         {
    
75.                 sda=1;
    
76.         }
    
77.         delay_4us();
    
78.         scl=1;
    
79.         delay_4us();
    
80.         scl=0;
    
81.         delay_4us();
    
82.         sda=1;
    
83.         delay_4us();
    
84.         scl=1;
    
85.         delay_4us();
    
86.         scl=0;
    
87.         
    
88. }
    
89. 
    
90. 
    
91. bit i2c_waitack()
    
92. {
    
93.         sda=1;
    
94.         delay_4us();
    
95.         scl=1;
    
96.         delay_4us();
    
97.         if(sda)
    
98.         {
    
99.                 scl=0;
    
100.                 i2c_stop();
     
101.                 return 0;
     
102.         }
     
103.         else
     
104.         {
     
105.                 scl=0;
     
106.                 return 1;
     
107.         }
     
108. }
     
109. 
     
110. 
     
111. void i2c_send(unchar byte)
     
112. {
     
113.         unchar i;
     
114.         for(i=0;i++;i<8)
     
115.         {
     
116.                 if(byte&0x80)
     
117.                 {
     
118.                         sda=1;
     
119.                 }
     
120.                 else
     
121.                 {
     
122.                         sda=0;
     
123.                 }
     
124.                 delay_4us();
     
125.                 byte<<=1;
     
126.                 delay_4us();
     
127.                 scl=0;
     
128.         }
     
129.         
     
130. }
     
131. 
     
132. 
     
133. unchar i2c_receive()
     
134. {
     
135.         unchar dat,i;
     
136.         for(i=0;i<8;i++)
     
137.         {
     
138.                 scl=1;
     
139.                 delay_4us();
     
140.                 dat <<=1;
     
141.                 if(sda)
     
142.                 {
     
143.                         dat|=0x01;
     
144.                 }
     
145.                 scl=0;
     
146.                 delay_4us();
     
147.         }
     
148.         return dat;
     
149. }
     
150. 
     
151. 
     
152. void ustart_init()
     
153. {
     
154.         PCON= 0x80;                //????????SMOD
     
155.         SCON= 0x50;                //8???,?????
     
156.   TMOD= 0x20;                //?????1?8???????
     
157.   TL1 = 0xF3;                //??????
     
158.   TH1 = 0xF3;
     
159.   ET1 = 0;                //?????1??
     
160.   TR1 = 1;                //?????1
     
161.   ES=1;                                                
     
162.   EA=1;
     
163. }
     
164. 
     
165. void ustart_send(unchar c)
     
166. {
     
167.         SBUF=c;
     
168.         while(!TI);
     
169.         TI=0;
     
170. }
     
171. 
     
172. 
     
173. void main()
     
174. {
     
175.         unchar temp[12] ="hguangqiang:";
     
176.         unchar i,j;
     
177.         unchar shuju;
     
178.         while(1)
     
179.         {
     
180.                
     
181.                 i2c_start();
     
182.                 i2c_send(0x90);
     
183.                 i2c_waitack();
     
184.                 i2c_send(0x00);
     
185.                 i2c_waitack();
     
186.                 i2c_send(0x91);
     
187.                 i2c_waitack();
     
188.                 shuju=i2c_receive();
     
189.                 i2c_ack(1);
     
190.                 i2c_stop();
     
191.                 dat[0]='0'+shuju/1000;
     
192.                 dat[1]='0'+shuju%1000/100;
     
193.                 dat[2]='0'+shuju%100/10;
     
194.                 dat[3]='0'+shuju%10;
     
195.                
     
196.                 ustart_init();
     
197.                 for(i=0;i<12;i++)
     
198.                 {
     
199.                         ustart_send(temp[i]);
     
200.                 }
     
201.                 delay(10000);
     
202.                 for(j=0;j<4;j++)
     
203.                 {
     
204.                         ustart_send(dat[j]);
     
205.                 }
     
206.                 delay(10000);
     
207.                
     
208.         }
     
209. 
     
210. }
     
211. 
     
212.         
     
213.         
     
214. 
     
215. 
     
216. void zhognduan() interrupt 4
     
217. {
     
218.         unchar receiveData;
     
219.         RI=0;
     
220.         receiveData=SBUF;
     
221.         SBUF=receiveData;
     
222.         while(!TI);
     
223.         TI=0;
     
224. }