24c256操作函数，连续读写

24c256的操作，在程序里搞了个连续读写的函数！很烦那页写跨页的问题，所以干脆做了个通用点的函数，小于3字节的写就用随机写，大于3字节的就用页写
真正供其他操作调用的函数是:
unchar SeqWriteTo24c256(unchar sla_add,unint addr_op,unchar write_size,unchar *write_buf);
unchar SeqReadFrom24c256(unchar sla_add,unint addr_op,unchar read_size,unchar *read_buf);
其他的都是本文件内自己调用的函数!!

1. //*****************************************************调试函数
   
2. void DebugEepromService(void)
   
3. {
   
4. unchar debug_buf[255];
   
5. debug_buf[0]=0x91;
   
6. debug_buf[1]=0x92;
   
7. debug_buf[2]=0x93;
   
8. debug_buf[3]=0x94;
   
9. debug_buf[4]=0x95;
   
10. debug_buf[250]=0x05;
    
11. debug_buf[251]=0x06;
    
12. debug_buf[252]=0x07;
    
13. debug_buf[253]=0x08;
    
14. debug_buf[254]=0x09;
    
15. SeqWriteTo24c256(EEP1_ADDR,1,255,debug_buf);
    
16. SeqReadFrom24c256(EEP1_ADDR,1,255,debug_buf);
    
17. }
    
18. //*************************************************************
    
19. 
    
20. 
    
21. 
    
22. #define IIC_SDA_PB 0x20
    
23. #define IIC_SCL_PB 0x80
    
24. #define IIC_DEL_WAIT 0x10 //>4.7us(12.80us) for Fre=11.0592M
    
25. #define IIC_DEL_WRITE 0x2700 //>6ms(7266.54us=7.266ms) for Fre=11.0592M
    
26. 
    
27. #define EEP1_ADDR 0xa4
    
28. #define PAGE_CAP_BYTE 64 //24C256页写容量:64字节
    
29. 
    
30. 
    
31. /*
    
32. 功能函数文件
    
33. 2005-9-22 9:54 by xth
    
34. 版本: v1.0
    
35. --------------------------------------------
    
36. Mcu: AVR mega32 Frequency: 11.0592M
    
37. --------------------------------------------
    
38. 功能概述:Eeprom操作文件
    
39. --------------------------------------------
    
40. */
    
41. //=============================函数声明
    
42. //----------IIC操作调用函数
    
43. void IicDelayService(unint delay_time);
    
44. void IicStartBitSend(void);
    
45. void IicStopBitSend(void);
    
46. void IicAckService(unchar ack_data);
    
47. unchar IicSendByteService(unchar tx_data);
    
48. unchar IicAccByteService(void);
    
49. //----------At24c256操作函数
    
50. unchar RandWriteByteTo24c256(unchar sla_add,unint addr_op,unchar data_op);
    
51. unchar WritePageTo24c256(unchar sla_add,unint addr_op,unchar *write_data_buf);
    
52. unchar SeqWriteTo24c256ByPage(unchar sla_add,unint addr_op,unchar write_size,unchar *write_buf);
    
53. unchar SeqWriteTo24c256(unchar sla_add,unint addr_op,unchar write_size,unchar *write_buf);
    
54. unchar SeqReadFrom24c256(unchar sla_add,unint addr_op,unchar read_size,unchar *read_buf);
    
55. //=============================函数定义
    
56. void IicDelayService(unint delay_count)
    
57. {
    
58. unint count;
    
59. for(count=0;count<delay_count;count++)
    
60. asm("NOP");
    
61. }
    
62. 
    
63. void IicStartBitSend(void)
    
64. {
    
65. PORTB |= IIC_SCL_PB; //发送起始条件的时钟信号
    
66. asm("NOP");
    
67. PORTB |= IIC_SDA_PB; //起始条件建立时间大于4.7us,延时
    
68. IicDelayService(IIC_DEL_WAIT);
    
69. PORTB &= ~IIC_SDA_PB;
    
70. IicDelayService(IIC_DEL_WAIT);
    
71. PORTB &= ~IIC_SCL_PB; //钳住I2C总线，准备发送或接收数据
    
72. asm("NOP");
    
73. }
    
74. 
    
75. void IicStopBitSend(void)
    
76. {
    
77. PORTB &= ~IIC_SDA_PB;//发送结束条件的时钟信号
    
78. IicDelayService(IIC_DEL_WAIT);
    
79. PORTB |= IIC_SCL_PB; //结束条件建立时间大于4μs
    
80. IicDelayService(IIC_DEL_WAIT);
    
81. PORTB |= IIC_SDA_PB;
    
82. asm("NOP");
    
83. }
    
84. 
    
85. void IicAckService(unchar ack_data)
    
86. {//作为主控器件应答->发应答或非应答信号
    
87. if(ack_data==0) PORTB &= ~IIC_SDA_PB;
    
88. else PORTB |= IIC_SDA_PB;
    
89. IicDelayService(IIC_DEL_WAIT);
    
90. PORTB |= IIC_SCL_PB;
    
91. IicDelayService(IIC_DEL_WAIT);
    
92. PORTB &= ~IIC_SCL_PB;//清时钟线，钳住I2C总线以便继续接收
    
93. asm("NOP");
    
94. }
    
95. 
    
96. unchar IicSendByteService(unchar tx_data)
    
97. {//将字节发送出去,可以是地址,也可以是数据,发完后等待应答并返回
    
98. unchar bit_count,ack_flag;
    
99. for(bit_count=0;bit_count<8;bit_count++)
    
100. {
     
101. if((tx_data<<bit_count)&0x80)
     
102. PORTB |= IIC_SDA_PB;
     
103. else
     
104. PORTB &= ~IIC_SDA_PB;
     
105. IicDelayService(IIC_DEL_WAIT);
     
106. PORTB |= IIC_SCL_PB; //置时钟线为高，通知被控器开始接收数据位
     
107. IicDelayService(IIC_DEL_WAIT); //保证时钟高电平周期大于4μs
     
108. PORTB &= ~IIC_SCL_PB;
     
109. }
     
110. IicDelayService(IIC_DEL_WAIT);
     
111. PORTB &= ~IIC_SDA_PB;
     
112. DDRB &= ~IIC_SDA_PB; //SDA置成输入
     
113. asm("NOP");
     
114. PORTB |= IIC_SCL_PB;
     
115. IicDelayService(IIC_DEL_WAIT);
     
116. IicDelayService(IIC_DEL_WAIT);
     
117. if(PINB&IIC_SDA_PB) //判断是否接收到应答信号
     
118. ack_flag=NO;
     
119. else
     
120. ack_flag=YES; //有应答信号
     
121. DDRB |= IIC_SDA_PB;
     
122. PORTB &= ~IIC_SCL_PB;
     
123. asm("NOP");
     
124. return(ack_flag);
     
125. }
     
126. 
     
127. unchar IicAccByteService(void)
     
128. {//接收从器件传来的数据,并判断总线错误
     
129. unchar bit_count,get_data;
     
130. DDRB &= ~IIC_SDA_PB;
     
131. get_data=0;
     
132. for(bit_count=0;bit_count<8;bit_count++)
     
133. {
     
134. asm("NOP");
     
135. PORTB &= ~IIC_SCL_PB; //置时钟线为低，准备接收数据位
     
136. IicDelayService(IIC_DEL_WAIT); //时钟低电平周期大于4.7μs;
     
137. PORTB |= IIC_SCL_PB; //置时钟线为高使数据线上数据有效
     
138. get_data<<=1;
     
139. if(PINB&IIC_SDA_PB)
     
140. get_data++;
     
141. asm("NOP");
     
142. asm("NOP");
     
143. }
     
144. PORTB &= ~IIC_SCL_PB;
     
145. DDRB |= IIC_SDA_PB;
     
146. asm("NOP");
     
147. return(get_data);
     
148. }
     
149. 
     
150. unchar RandWriteByteTo24c256(unchar sla_add,unint addr_op,unchar data_op)
     
151. {
     
152. unchar result_now,temp_data;
     
153. IicStartBitSend(); //起始条件
     
154. temp_data=sla_add; //从器件地址
     
155. result_now=IicSendByteService(temp_data);
     
156. if(result_now==NO) return(result_now);
     
157. temp_data=addr_op>>8; //操作单元地址高8位
     
158. result_now=IicSendByteService(temp_data);
     
159. if(result_now==NO) return(result_now);
     
160. temp_data=addr_op; //操作单元地址低8位
     
161. result_now=IicSendByteService(temp_data);
     
162. if(result_now==NO) return(result_now);
     
163. temp_data=data_op; //操作数据
     
164. result_now=IicSendByteService(temp_data);
     
165. if(result_now==NO) return(result_now);
     
166. IicStopBitSend(); //停止条件
     
167. IicDelayService(IIC_DEL_WRITE);
     
168. result_now=YES;
     
169. return(result_now);
     
170. }
     
171. 
     
172. unchar SeqReadFrom24c256(unchar sla_add,unint addr_op,unchar read_size,unchar *read_buf)
     
173. {//addr “roll over” during read:from last byte of the last page, to the first byte of the first page
     
174. unchar result_now,temp_data,read_count;
     
175. IicStartBitSend(); //起始条件
     
176. temp_data=sla_add; //从器件地址
     
177. result_now=IicSendByteService(temp_data);
     
178. if(result_now==NO) return(result_now);
     
179. temp_data=addr_op>>8; //操作单元地址高8位
     
180. result_now=IicSendByteService(temp_data);
     
181. if(result_now==NO) return(result_now);
     
182. temp_data=addr_op; //操作单元地址低8位
     
183. result_now=IicSendByteService(temp_data);
     
184. if(result_now==NO) return(result_now);
     
185. IicStartBitSend();
     
186. temp_data=sla_add+1; //读操作
     
187. result_now=IicSendByteService(temp_data);
     
188. if(result_now==NO) return(result_now);
     
189. for(read_count=0;read_count<read_size-1;read_count++)
     
190. { //连续读数据
     
191. *(read_buf+read_count)=IicAccByteService();
     
192. IicAckService(NO);
     
193. }
     
194. *(read_buf+read_count)=IicAccByteService();
     
195. IicAckService(YES);
     
196. IicStopBitSend();
     
197. result_now=YES;
     
198. return(result_now);
     
199. }
     
200. 
     
201. unchar WritePageTo24c256(unchar sla_add,unint addr_op,unchar *write_data_buf)
     
202. {//页写
     
203. unchar count,result_now,temp_data;
     
204. IicStartBitSend(); //起始条件
     
205. temp_data=sla_add; //从器件地址
     
206. result_now=IicSendByteService(temp_data);
     
207. if(result_now==NO) return(result_now);
     
208. temp_data=addr_op>>8; //操作单元地址高8位
     
209. result_now=IicSendByteService(temp_data);
     
210. if(result_now==NO) return(result_now);
     
211. temp_data=addr_op; //操作单元地址低8位
     
212. result_now=IicSendByteService(temp_data);
     
213. if(result_now==NO) return(result_now);
     
214. for(count=0;count<PAGE_CAP_BYTE;count++)
     
215. {//连续写
     
216. temp_data=*(write_data_buf+count);
     
217. result_now=IicSendByteService(temp_data);
     
218. if(result_now==NO) return(result_now);
     
219. }
     
220. IicStopBitSend(); //停止条件
     
221. IicDelayService(IIC_DEL_WRITE);
     
222. result_now=YES;
     
223. return(result_now);
     
224. }
     
225. 
     
226. unchar SeqWriteTo24c256ByPage(unchar sla_add,unint addr_op,unchar write_size,unchar *write_buf)
     
227. {//addr “roll over” during write:from last byte of the current page to first byte of the same page.
     
228. unint page_write,read_addr,temp_op_int;
     
229. unchar data_count,result_out,modify_count,count,write_data_buf[PAGE_CAP_BYTE];
     
230. result_out=YES;
     
231. data_count=0;
     
232. while(write_size>0)
     
233. {
     
234. page_write=addr_op/PAGE_CAP_BYTE; //得到当前页
     
235. read_addr=page_write*PAGE_CAP_BYTE;
     
236. SeqReadFrom24c256(sla_add,read_addr,PAGE_CAP_BYTE,write_data_buf);
     
237. temp_op_int=addr_op&(PAGE_CAP_BYTE-1); //得到在页内的起始字节地址
     
238. if(temp_op_int+write_size>=PAGE_CAP_BYTE)
     
239. {
     
240. modify_count=PAGE_CAP_BYTE;
     
241. addr_op=(page_write+1)*PAGE_CAP_BYTE; //写下一页的起始地址
     
242. }
     
243. else
     
244. modify_count=write_size;
     
245. count=temp_op_int;
     
246. write_size=write_size-modify_count+count; //写下一页的数据量
     
247. for(;count<modify_count;count++,data_count++)
     
248. write_data_buf[count]=*(write_buf+data_count);
     
249. result_out=WritePageTo24c256(sla_add,read_addr,write_data_buf);
     
250. }
     
251. return(result_out);
     
252. }
     
253. 
     
254. unchar SeqWriteTo24c256(unchar sla_add,unint addr_op,unchar write_size,unchar *write_buf)
     
255. {//连续写(非页写)
     
256. unchar write_result;
     
257. if(write_size<3)
     
258. {//如果要写入的数据小于3个,则用随机写实现
     
259. write_result=RandWriteByteTo24c256(sla_add,addr_op,*write_buf);
     
260. write_result=RandWriteByteTo24c256(sla_add,addr_op+1,*(write_buf+1));
     
261. }
     
262. else
     
263. write_result=SeqWriteTo24c256ByPage(sla_add,addr_op,write_size,write_buf);
     
264. return(write_result);
     
265. }
     

复制代码