用GCC写的PCF8563和FM24C256程序，已经在MEGA8L调试通过

1. #include <AVR/io.h>
   
2. #include <avr/twi.h>
   
3. #include <avr/signal.h>
   
4. #define fosc 7372800
   
5. #define sla 0xa0
   
6. #define slav 0xa2
   
7. #define TW_WRITE 0
   
8. #define TW_READ 1
   
9. #define max 3
   
10. #define uchar unsigned char
    
11. #define uint unsigned int
    
12. #define ulong unsigned long
    
13. 
    
14. void Twi_Init( void )
    
15. {
    
16. TWBR = 0x20;//设置波特率
    
17. TWSR &= 0xfc;//设置预分频因子,则SCL频率为92160Hz
    
18. }
    
19. 
    
20. /*----------------------------------------------------------------------
    
21. 功 能：将读出的时间数据的无关位屏蔽掉
    
22. 说 明：hym8563时钟寄存器的有些无关位的状态是不定的，所以应该将无效位屏蔽掉
    
23. ----------------------------------------------------------------------*/
    
24. void Datajust(void)
    
25. {
    
26. trdata[0]=trdata[0]&0x7f;
    
27. trdata[1]=trdata[1]&0x7f;
    
28. trdata[2]=trdata[2]&0x3f;
    
29. trdata[3]=trdata[3]&0x3f;
    
30. trdata[4]=trdata[4]&0x07;
    
31. trdata[5]=trdata[5]&0x1f;
    
32. trdata[6]=trdata[6]&0xff;
    
33. }
    
34. 
    
35. uchar FM24C256_Write( uint address,uchar write_data )
    
36. {
    
37. uchar twst,n=0x0,rv=0x1;
    
38. restart:
    
39. if(n++>=max)
    
40. goto error;
    
41. begin:
    
42. TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);//发送开始信号
    
43. while((TWCR & _BV(TWINT))==0x0);//等待发送完毕
    
44. switch((twst = TW_STATUS))
    
45. {
    
46. case TW_REP_START://有可能出现
    
47. case TW_START:
    
48. break;
    
49. case TW_MT_ARB_LOST:
    
50. goto begin;
    
51. default:
    
52. goto error;
    
53. }
    
54. TWDR = sla | TW_WRITE;//发送SLA+W
    
55. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
    
56. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
    
57. switch((twst = TW_STATUS))
    
58. {
    
59. case TW_MT_SLA_ACK:
    
60. break;
    
61. case TW_MT_SLA_NACK://器件忙,有可能处于内部写周期
    
62. goto restart;
    
63. case TW_MT_ARB_LOST:
    
64. goto begin;
    
65. default:
    
66. goto error;
    
67. }
    
68. TWDR = address>>8;//传输地址高8位
    
69. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
    
70. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
    
71. switch((twst = TW_STATUS))
    
72. {
    
73. case TW_MT_DATA_ACK:
    
74. break;
    
75. case TW_MT_DATA_NACK:
    
76. goto quit;
    
77. case TW_MT_ARB_LOST:
    
78. goto begin;
    
79. default:
    
80. goto error;
    
81. }
    
82. TWDR = address;//传输地址低8位
    
83. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
    
84. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
    
85. switch((twst = TW_STATUS))
    
86. {
    
87. case TW_MT_DATA_ACK:
    
88. break;
    
89. case TW_MT_DATA_NACK:
    
90. goto quit;
    
91. case TW_MT_ARB_LOST:
    
92. goto begin;
    
93. default:
    
94. goto error;
    
95. }
    
96. TWDR = write_data;
    
97. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
    
98. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
    
99. switch((twst = TW_STATUS))
    
100. {
     
101. case TW_MT_DATA_ACK:
     
102. break;
     
103. default:
     
104. goto error;
     
105. }
     
106. quit:
     
107. TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN);//发送停止信号
     
108. return rv;
     
109. error:
     
110. rv=0x0;
     
111. goto quit;
     
112. 
     
113. }
     
114. 
     
115. uchar FM24C256_Read( uint address )
     
116. {
     
117. uchar twst,n=0x0,rv=0x1;
     
118. restart:
     
119. if(n++>=max)
     
120. goto error;
     
121. begin:
     
122. TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);//发送开始信号
     
123. while((TWCR & _BV(TWINT))==0x0);//等待发送完毕
     
124. switch((twst = TW_STATUS))
     
125. {
     
126. case TW_REP_START://有可能出现
     
127. case TW_START:
     
128. break;
     
129. case TW_MT_ARB_LOST:
     
130. goto begin;
     
131. default:
     
132. goto error;
     
133. }
     
134. TWDR = sla | TW_WRITE;//发送SLA+W
     
135. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
136. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
137. switch((twst = TW_STATUS))
     
138. {
     
139. case TW_MT_SLA_ACK:
     
140. break;
     
141. case TW_MT_SLA_NACK://器件忙,有可能处于内部写周期
     
142. goto restart;
     
143. case TW_MT_ARB_LOST:
     
144. goto begin;
     
145. default:
     
146. goto error;
     
147. }
     
148. TWDR = address>>8;//传输地址高8位
     
149. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
150. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
151. switch((twst = TW_STATUS))
     
152. {
     
153. case TW_MT_DATA_ACK:
     
154. break;
     
155. case TW_MT_DATA_NACK:
     
156. goto quit;
     
157. case TW_MT_ARB_LOST:
     
158. goto begin;
     
159. default:
     
160. goto error;
     
161. }
     
162. TWDR = address;//传输地址低8位
     
163. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
164. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
165. switch((twst = TW_STATUS))
     
166. {
     
167. case TW_MT_DATA_ACK:
     
168. break;
     
169. case TW_MT_DATA_NACK:
     
170. goto quit;
     
171. case TW_MT_ARB_LOST:
     
172. goto begin;
     
173. default:
     
174. goto error;
     
175. }
     
176. TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);//发送(重新)开始信号
     
177. while((TWCR & _BV(TWINT))==0x0);//等待发送完毕
     
178. switch((twst = TW_STATUS))
     
179. {
     
180. case TW_REP_START://正确的状态
     
181. break;
     
182. case TW_MT_ARB_LOST:
     
183. goto begin;
     
184. default:
     
185. goto error;
     
186. }
     
187. TWDR = sla | TW_READ;//发送SLA+R
     
188. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
189. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
190. switch((twst = TW_STATUS))
     
191. {
     
192. case TW_MR_SLA_ACK:
     
193. break;
     
194. case TW_MR_SLA_NACK://器件忙,有可能处于内部写周期
     
195. goto restart;
     
196. case TW_MR_ARB_LOST:
     
197. goto begin;
     
198. default:
     
199. goto error;
     
200. }
     
201. TWCR = _BV(TWINT) | _BV(TWEN) ;//清TWINT,开始传输
     
202. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
203. switch((twst = TW_STATUS))
     
204. {
     
205. case TW_MR_DATA_NACK:
     
206. rv = TWDR;
     
207. break;
     
208. default:
     
209. goto error;
     
210. }
     
211. quit:
     
212. TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN);//发送停止信号
     
213. return rv;
     
214. error:
     
215. rv=0x0;
     
216. goto quit;
     
217. }
     
218. 
     
219. uchar SetHym8563(uchar suba,uchar *s,uchar no )
     
220. {
     
221. uchar twst,i,n=0x0,rv=0x1;
     
222. restart:
     
223. if(n++>=max)
     
224. goto error;
     
225. begin:
     
226. TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);//发送开始信号
     
227. while((TWCR & _BV(TWINT))==0x0);//等待发送完毕
     
228. switch((twst = TW_STATUS))
     
229. {
     
230. case TW_REP_START://有可能出现
     
231. case TW_START:
     
232. break;
     
233. case TW_MT_ARB_LOST:
     
234. goto begin;
     
235. default:
     
236. goto error;
     
237. }
     
238. TWDR = slav | TW_WRITE;//发送SLAV+W
     
239. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
240. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
241. 
     
242. switch((twst = TW_STATUS))
     
243. {
     
244. case TW_MT_SLA_ACK:
     
245. break;
     
246. case TW_MT_SLA_NACK://器件忙,有可能处于内部写周期
     
247. goto restart;
     
248. case TW_MT_ARB_LOST:
     
249. goto begin;
     
250. default:
     
251. goto error;
     
252. }
     
253. TWDR = suba | TW_WRITE;//发送SUBA+W
     
254. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
255. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
256. 
     
257. switch((twst = TW_STATUS))
     
258. {
     
259. case TW_MT_DATA_ACK:
     
260. break;
     
261. case TW_MT_DATA_NACK://器件忙,有可能处于内部写周期
     
262. goto restart;
     
263. case TW_MT_ARB_LOST:
     
264. goto begin;
     
265. default:
     
266. goto error;
     
267. }
     
268. for(i=0;i<no;i++)
     
269. {
     
270. TWDR = *s | TW_WRITE;
     
271. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
272. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
273. switch((twst = TW_STATUS))
     
274. {
     
275. case TW_MT_DATA_ACK:
     
276. break;
     
277. case TW_MT_DATA_NACK://器件忙,有可能处于内部写周期
     
278. goto restart;
     
279. case TW_MT_ARB_LOST:
     
280. goto begin;
     
281. default:
     
282. goto error;
     
283. }
     
284. s++;
     
285. }
     
286. quit:
     
287. TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN);//发送停止信号
     
288. return rv;
     
289. error:
     
290. rv=0x0;
     
291. goto quit;
     
292. }
     
293. 
     
294. uchar GetHym8563(uchar suba,uchar *s,uchar no)
     
295. {
     
296. uchar twst,i,n=0x0,rv=0x1;
     
297. restart:
     
298. if(n++>=max)
     
299. goto error;
     
300. begin:
     
301. TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);//发送开始信号
     
302. while((TWCR & _BV(TWINT))==0x0);//等待发送完毕
     
303. switch((twst = TW_STATUS))
     
304. {
     
305. case TW_REP_START://有可能出现
     
306. case TW_START:
     
307. break;
     
308. case TW_MT_ARB_LOST:
     
309. goto begin;
     
310. default:
     
311. goto error;
     
312. }
     
313. TWDR = slav | TW_WRITE;//发送SLAV+W
     
314. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
315. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
316. 
     
317. switch((twst = TW_STATUS))
     
318. {
     
319. case TW_MT_SLA_ACK:
     
320. break;
     
321. case TW_MT_SLA_NACK://器件忙,有可能处于内部写周期
     
322. goto restart;
     
323. case TW_MT_ARB_LOST:
     
324. goto begin;
     
325. default:
     
326. goto error;
     
327. }
     
328. TWDR = suba | TW_WRITE;//发送SUBA+W
     
329. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
330. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
331. 
     
332. switch((twst = TW_STATUS))
     
333. {
     
334. case TW_MT_DATA_ACK:
     
335. break;
     
336. case TW_MT_DATA_NACK://器件忙,有可能处于内部写周期
     
337. goto restart;
     
338. case TW_MT_ARB_LOST:
     
339. goto begin;
     
340. default:
     
341. goto error;
     
342. }
     
343. TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);//发送(重新)开始信号
     
344. while((TWCR & _BV(TWINT))==0x0);//等待发送完毕
     
345. 
     
346. switch((twst = TW_STATUS))
     
347. {
     
348. case TW_REP_START://正确的状态
     
349. break;
     
350. case TW_MT_ARB_LOST:
     
351. goto begin;
     
352. default:
     
353. goto error;
     
354. }
     
355. TWDR = slav | TW_READ;//发送SLAV+R
     
356. TWCR = _BV(TWINT) | _BV(TWEN);//清TWINT,开始传输
     
357. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
358. 
     
359. switch((twst = TW_STATUS))
     
360. {
     
361. case TW_MR_SLA_ACK:
     
362. break;
     
363. case TW_MR_SLA_NACK://器件忙,有可能处于内部写周期
     
364. goto restart;
     
365. case TW_MR_ARB_LOST:
     
366. goto begin;
     
367. default:
     
368. goto error;
     
369. }
     
370. for(i=0;i<no;i++)
     
371. {
     
372. if(i==(no-1))
     
373. {
     
374. TWCR = _BV(TWINT) | _BV(TWEN) ;//清TWINT,开始传输(无应答)
     
375. }
     
376. else
     
377. {
     
378. TWCR = _BV(TWINT) | _BV(TWEN) | _BV(TWEA) ;//清TWINT,开始传输(有应答)
     
379. }
     
380. while((TWCR & _BV(TWINT))==0x0);//等待传输完毕
     
381. switch((twst = TW_STATUS))
     
382. {
     
383. case TW_MR_DATA_NACK:
     
384. case TW_MR_DATA_ACK:
     
385. *s = TWDR;
     
386. s++;
     
387. break;
     
388. default:
     
389. goto error;
     
390. }
     
391. }
     
392. quit:
     
393. TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN);//发送停止信号
     
394. return rv;
     
395. error:
     
396. rv=0x0;
     
397. goto quit;
     
398. }
     

复制代码