标题: AT24C02 IIC驱动 C代码 [打印本页]

---

作者: xiaos    时间: 2015-4-10 17:26
标题: AT24C02 IIC驱动 C代码

1. #define SCL_L  //拉低SCL线的宏
   
2. #define SCL_H  //拉高SCL线的宏
   
3. #define SDA_L  //拉低SDA线的宏
   
4. #define SDA_H  //拉高SDA线的宏
   
5. #define SDA_Read //读SDA线的宏
   
6. #define Wait //延时宏 大约为5us
   
7. 
   
8. void IIC_Start(void)//启动IIC函数
   
9. {
   
10.     SDA_H;
    
11.     SCL_H;
    
12.     Wait;
    
13.     SDA_L;
    
14.     Wait;
    
15.     SCL_L;
    
16.     Wait;
    
17. }
    
18. void IIC_Stop(void)//停止IIC函数
    
19. {
    
20.     SDA_L;
    
21.     SCL_H;
    
22.     Wait;
    
23.     SDA_H;
    
24. }
    
25. void IIC_Send_Byte(uint8_t data)//想IIC器件发送8个位数据
    
26. {
    
27.     uint8_t i;
    
28.     for(i=0;i<8;i++)
    
29.     {
    
30.         if(data&(0x80>>i))
    
31.             SDA_H;
    
32.         else
    
33.              SDA_L;
    
34.         Wait;
    
35.         SCL_H;
    
36.         Wait;
    
37.         SCL_L;
    
38.         Wait;
    
39.     }
    
40.         SDA_H;
    
41.         Wait;
    
42. }
    
43. 
    
44. uint8_t IIC_Read_Byte()//读取8位数据
    
45. {
    
46.     uint8_t i,buff=0x00;
    
47.     for(i=0;i<8;i++)
    
48.     {
    
49.         buff<<=1;
    
50.         SCL_H;
    
51.         Wait;
    
52.         if(SDA_Read)
    
53.             buff|=0x01;
    
54.         SCL_L;
    
55.         Wait;
    
56.     }
    
57.     return buff;
    
58. }
    
59. 
    
60. uint8_t Wait_Ack(void)//等待应答
    
61. {
    
62.     uint8_t flag;
    
63.     SDA_H;
    
64.     Wait;
    
65.     SCL_H;
    
66.     Wait;
    
67.     if(SDA_Read)
    
68.         flag=1;
    
69.     else
    
70.         flag=0;
    
71.     SCL_L;
    
72.     Wait;
    
73.     return flag;
    
74. }
    
75. 
    
76. void Ack(void)//发送应答
    
77. {
    
78.     SDA_L;
    
79.     Wait;
    
80.     SCL_H;
    
81.     Wait;
    
82.     SCL_L;
    
83.     Wait;
    
84.     SDA_H;
    
85. }
    
86. 
    
87. void NAck(void)//发送非应答
    
88. {
    
89.     SDA_H;
    
90.     Wait;
    
91.     SCL_H;
    
92.     Wait;
    
93.     SCL_L;
    
94.     Wait;
    
95. }
    
96. 
    
97. uint8_t AT24C02_Pag_Write(uint8_t address,uint8_t *data,uint8_t size)//AT24C02写数据函数  第一个参数是 AT24C02的要写页的地址 0-255,第二个参数是 缓冲区指针,第三个参数是 要写的字节数//不能超过8个字节
    
98. {
    
99.     uint8_t i;
    
100.     IIC_Stop();
     
101.     for(i=0;i<100;i++)
     
102.     {
     
103.         IIC_Start();
     
104.         IIC_Send_Byte(0xa0);
     
105.         if(Wait_Ack()==0)
     
106.             {
     
107.                 break;
     
108.             }
     
109.     }
     
110.     if(m=100)
     
111.     {
     
112.         IIC_Stop();
     
113.         return 0;   
     
114.     }
     
115.     IIC_Send_Byte(address);
     
116.     if(Wait_Ack())
     
117.         {
     
118.                IIC_Stop();
     
119.             return 0;
     
120.         }
     
121.     for(i=0;i<size;i++)
     
122.     {
     
123.         IIC_Send_Byte(*(data+i));
     
124.         if(Wait_Ack())
     
125.             {
     
126.                 IIC_Stop();
     
127.                 return 0;
     
128.             }
     
129.     }
     
130.     IIC_Stpo();
     
131.     return 1;
     
132. }
     
133. uint8_t AT24C02_Write(uint8_t address,uint8_t *data,uint8_t size)//对任意AT24C02的地址进行写操作  其中第一个参数是 AT24C02要写的地址 第二个参数是 缓冲区指针 第三个参数是 要写的字节数 0-255;
     
134. {
     
135.     uint8_t Page=0;//所需要的页数
     
136.     uint8_t Cont=0;//不足一页的字节数
     
137.     uint8_t Add_Pag=0;//某一页已经写了的字节数
     
138.     uint8_t Sur=0;//某一页还能写的字节数
     
139.    
     
140.     Page=size/8;
     
141.     Cont=size%8;
     
142.     Add_Pag=address%8;
     
143.     Sur=8-Add_Pag;
     
144.    
     
145.     if(Add_Pag==0)
     
146.     {
     
147.         if(Page==0)
     
148.         {
     
149.             AT24C02_Pag_Write(address,data,size);
     
150.             Delay();//此函数没有定义 需要自己定义 大约延时2000us
     
151.         }
     
152.         else
     
153.         {
     
154.             while(Page--)
     
155.             {
     
156.                 AT24C02_Pag_Write(address,data,8);
     
157.                 Delay();
     
158.                 address+=8;
     
159.                 data+=8;
     
160.             }
     
161.             if(Cont!=0)
     
162.             {
     
163.                 AT24C02_Pag_Write(address,data,Cont);
     
164. Delay(2000);
     
165.             }
     
166.         }
     
167.     }
     
168.     else
     
169.     {
     
170.         if(Page==0)
     
171.         {
     
172.             if(Sur>=size)
     
173.             {
     
174.                 AT24C02_Pag_Write(address,data,size);
     
175.                 Delay;
     
176.             }
     
177.             else
     
178.             {
     
179.                 AT24C02_Pag_Write(address,data,Sur);
     
180.                 Delay;
     
181.                 address+=Sur;
     
182.                 data+=Sur;
     
183.                 AT24C02_Pag_Write(address,data,size-Sur) ;
     
184.                 Delay;
     
185.             }
     
186.         }
     
187.         else
     
188.         {
     
189.             AT24C02_Pag_Write(address,data,Sur);
     
190. Delay(2000);
     
191. address+=Sur;
     
192. data+=Sur;
     
193. Page=size/8;
     
194. Cont=size%8;
     
195. Add_Page=address%8;
     
196. Sur=8-Add_Page;
     
197. if(Page==0)//
     
198. {
     
199.         AT24C02_Pag_Write(address,data,size);
     
200.         Delay(2000);
     
201. }
     
202. else//
     
203. {
     
204. while(Page--)
     
205. {
     
206. AT24C02_Pag_Write(address,data,8);
     
207. Delay(2000);
     
208. address+=8;
     
209. data+=8;
     
210. }
     
211.             if(Cont!=0)
     
212. {
     
213. AT24C02_Pag_Write(address,data,Cont);
     
214. Delay(2000);
     
215. }
     
216. }
     
217.         }
     
218.     }
     
219. }
     
220. 
     
221. 
     
222. uint8_t AT24C02_Read(uint8_t address,uint8_t *data,uint8_t size)//从AT24C02读取size个字节 第一个参数是 读AT24C02 的数据的首地址 第二个参数是 缓冲区指针 第三个参数是 要读取的字节数
     
223. {
     
224.     uint8_t i;
     
225.     IIC_Start();
     
226.     IIC_Send_Byte(0xa0);
     
227.     if(Wait_Ack())
     
228.     {
     
229.         IIC_Stop();
     
230.         return 0;
     
231.     }
     
232.     IIC_Send_Byte(address)
     
233.     if(Wait_Ack())
     
234.     {
     
235.         IIC_Stop();
     
236.         return 0;
     
237.     }
     
238.     IIC_Start();
     
239.     IIC_Send_Byte(0xa1);
     
240.     if(Wait_Ack())
     
241.     {
     
242.         IIC_Stop();
     
243.         return 0;
     
244.     }
     
245.     for(i=0;i<size;i++)
     
246.     {
     
247.         *(data+i)=IIC_Read_Byte();
     
248.         if(i!=size-1)
     
249.         {
     
250.             Ack();
     
251.         }
     
252.         else
     
253.         {
     
254.             NAck();
     
255.         }
     
256.     }
     
257.     IIC_Stop();
     
258.     return 1;
     
259. }

复制代码

---

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

Powered by Discuz! X3.1