SAM4E-EK开发板代码解读11——EEPROM

Mcuzone_TKN

关键词：Microchip Atmel  SAM4E SAM4E-EK  SAM4E16E 芯片 PCF8563 EEPROM

概述：简要解读EEPROM

EEPROM（带电可擦除编程只读存储器）是用户可更改的只读存储器（ROM），其可通过高于普通电压的作用来擦除和重新编程（重写）。

EEPROM以Byte为最小修改单位，不必将资料全部洗掉才能写入。

打开产品光盘SAM4E16E-EK/SAM4E16E-EK中文资料/softpack软件包/Atmel Studio 7,打开13a_TWI_MASTER_EXAMPLE_eeprom例子。

int main(void)
{
uint32_t i;
twi_options_t opt;
twi_packet_t packet_tx, packet_rx;

//初始化SAM系统
sysclk_init();
board_init();

//初始化控制台uart
configure_console();

//输出示例信息
puts(STRING_HEADER);

//配置systick为1ms
puts("Configure system tick to get 1ms tick period.\r");
if (SysTick_Config(sysclk_get_cpu_hz() / 1000)) {
  puts("-F- Systick configuration error\r");
  while (1);
}
    //使能TWI外部时钟
   

pmc_enable_periph_clk(BOARD_ID_TWI_EEPROM);

    //配置TWI驱动程序的选项

    opt.master_clk = sysclk_get_cpu_hz();
    opt.speed      = TWI_CLK;

    //配置要传送的数据包

    packet_tx.chip        = AT24C_ADDRESS;
    packet_tx.addr[0]     = EEPROM_MEM_ADDR >> 8;
    packet_tx.addr[1]     = EEPROM_MEM_ADDR;
    packet_tx.addr_length = EEPROM_MEM_ADDR_LENGTH;
    packet_tx.buffer      = (uint8_t *) test_data_tx;
    packet_tx.length      = TEST_DATA_LENGTH;

    //配置要接收的数据包
    packet_rx.chip        = packet_tx.chip;
    packet_rx.addr[0]     = packet_tx.addr[0];
    packet_rx.addr[1]     = packet_tx.addr[1];
    packet_rx.addr_length = packet_tx.addr_length;
    packet_rx.buffer      = gs_uc_test_data_rx;
    packet_rx.length      = packet_tx.length;

    if (twi_master_init(BOARD_BASE_TWI_EEPROM, &opt) != TWI_SUCCESS) {
     puts("-E-\tTWI master initialization failed.\r");
     
     while (1) ;
    }

    //发送测试模式到EEPROM
    if (twi_master_write(BOARD_BASE_TWI_EEPROM, &packet_tx) != TWI_SUCCESS) {
     puts("-E-\tTWI master write packet failed.\r");
   
     while (1) ;
    }
    printf("Write:\tOK!\n\r");

    //等待至少10ms
    mdelay(WAIT_TIME);
   
    //从EEPROM获得内存
    if (twi_master_read(BOARD_BASE_TWI_EEPROM, &packet_rx) != TWI_SUCCESS) {
     puts("-E-\tTWI master read packet failed.\r");
   
    while (1) ;
    }
    puts("Read:\tOK!\r");

    //比较发送和接收
    for (i = 0; i < TEST_DATA_LENGTH; i++) {
     if (test_data_tx != gs_uc_test_data_rx) {
  puts("Data comparison:\tUnmatched!\r");
      
    while (1) ;
     }
    }
    puts("Data comparison:\tMatched!\r");
     
  while (1) ;

}

Mcuzone_TKN

初始化

1. #define I2C_FAST_MODE_SPEED  400000
   
2. #define TWI_CLK_DIVIDER      2
   
3. #define TWI_CLK_CALC_ARGU    4
   
4. #define TWI_CLK_DIV_MAX      0xFF
   
5. #define TWI_CLK_DIV_MIN      7

复制代码

Mcuzone_TKN

1. //使能TWI主模式
   
2. [color=Red]void twi_enable_master_mode(Twi *p_twi)[/color]
   
3. {
   
4.         //设置主禁用位和从禁用位
   
5.         p_twi->TWI_CR = TWI_CR_MSDIS;
   
6.         p_twi->TWI_CR = TWI_CR_SVDIS;
   
7. 
   
8.         //设置主使能位
   
9.         p_twi->TWI_CR = TWI_CR_MSEN;
   
10. }
    
11. 
    
12. //暂时禁用TWI主控模式
    
13. void twi_disable_master_mode(Twi *p_twi)
    
14. {
    
15.         //设置主禁用位
    
16.         p_twi->TWI_CR = TWI_CR_MSDIS;
    
17. }
    
18. 
    
19. //初始化TWI模式
    
20. 如果初始化成功 就返回TWI_SUCCESS,否则返回错误代码
    
21. uint32_t twi_master_init(Twi *p_twi, const twi_options_t *p_opt)
    
22. {
    
23.         uint32_t status = TWI_SUCCESS;
    
24. 
    
25.         //关闭TWI中断
    
26.         p_twi->TWI_IDR = ~0UL;
    
27. 
    
28.         //虚拟读状态寄存器
    
29.         p_twi->TWI_SR;
    
30. 
    
31.         //复位TWI外设
    
32.         twi_reset(p_twi);
    
33. 
    
34.         twi_enable_master_mode(p_twi);
    
35. 
    
36.         //选择速度
    
37.         if (twi_set_speed(p_twi, p_opt->speed, p_opt->master_clk) == FAIL) {
    
38.                 //所需的速度设置被拒绝
    
39.                 status = TWI_INVALID_ARGUMENT;
    
40.         }
    
41. 
    
42.         if (p_opt->smbus == 1) {
    
43.                 p_twi->TWI_CR = TWI_CR_QUICK;
    
44.         }
    
45. 
    
46.         return status;
    
47. }
    
48. 
    
49. //设置I2C总线速度与时钟频率
    
50. uint32_t twi_set_speed(Twi *p_twi, uint32_t ul_speed, uint32_t ul_mck)
    
51. {
    
52.         uint32_t ckdiv = 0;
    
53.         uint32_t c_lh_div;
    
54. 
    
55.         if (ul_speed > I2C_FAST_MODE_SPEED) {
    
56.                 return FAIL;
    
57.         }
    
58. 
    
59.         c_lh_div = ul_mck / (ul_speed * TWI_CLK_DIVIDER) - TWI_CLK_CALC_ARGU;
    
60. 
    
61.         //cldiv必须适合8位，cldiv必须适合3位
    
62.         while ((c_lh_div > TWI_CLK_DIV_MAX) && (ckdiv < TWI_CLK_DIV_MIN)) {
    
63.                 //增加时钟分压器
    
64.                 ckdiv++;
    
65.                 //分割cldiv值
    
66.                 c_lh_div /= TWI_CLK_DIVIDER;
    
67.         }
    
68. 
    
69.         //设置时钟波形发生器寄存器
    
70.         p_twi->TWI_CWGR =
    
71.                         TWI_CWGR_CLDIV(c_lh_div) | TWI_CWGR_CHDIV(c_lh_div) |
    
72.                         TWI_CWGR_CKDIV(ckdiv);
    
73. 
    
74.         return PASS;
    
75. }
    
76. 
    
77. //测试芯片是否响应给指定的I2C地址
    
78. 如果找到芯片 返回TWI_SUCCESS,否则返回错误代码
    
79. uint32_t twi_probe(Twi *p_twi, uint8_t uc_slave_addr)
    
80. {
    
81.         twi_packet_t packet;
    
82.         uint8_t data = 0;
    
83. 
    
84.         //发送数据
    
85.         packet.buffer = &data;
    
86.         //数据长度
    
87.         packet.length = 1;
    
88.         //从芯片地址
    
89.         packet.chip = (uint32_t) uc_slave_addr;
    
90.         //芯片内部地址
    
91.         packet.addr[0] = 0;
    
92.         //地址长度
    
93.         packet.addr_length = 0;
    
94. 
    
95.         //执行主写访问
    
96.         return (twi_master_write(p_twi, &packet));
    
97. }
    
98. 
    
99. 
    
100. //内部构造TWI模块地址寄存器字段
     
101. TWI模块地址寄存器先发送MSB，尺寸控制哪一个字节是MSB开始
     
102. static uint32_t twi_mk_addr(const uint8_t *addr, int len)
     
103. {
     
104.         uint32_t val;
     
105. 
     
106.         if (len == 0)
     
107.                 return 0;
     
108. 
     
109.         val = addr[0];
     
110.         if (len > 1) {
     
111.                 val <<= 8;
     
112.                 val |= addr[1];
     
113.         }
     
114.         if (len > 2) {
     
115.                 val <<= 8;
     
116.                 val |= addr[2];
     
117.         }
     
118.         return val;
     
119. }
     
120. 
     
121. //从一个TWI兼容的从设备读取多个字节
     
122. 在所有数据被读取或出现错误之前，此函数不会返回
     
123. 如果读取了所有字节，返回TWI_SUCCESS,否则返回错误代码
     
124. uint32_t twi_master_read(Twi *p_twi, twi_packet_t *p_packet)
     
125. {
     
126.         uint32_t status, cnt = p_packet->length;
     
127.         uint8_t *buffer = p_packet->buffer;
     
128.        
     
129.         //检查参数
     
130.         if (cnt == 0) {
     
131.                 return TWI_INVALID_ARGUMENT;
     
132.         }
     
133. 
     
134.         //设置读取模式，从地址和3个内部地址字节长度
     
135.         p_twi->TWI_MMR = 0;
     
136.         p_twi->TWI_MMR = TWI_MMR_MREAD | TWI_MMR_DADR(p_packet->chip) |
     
137.                         ((p_packet->addr_length << TWI_MMR_IADRSZ_Pos) &
     
138.                         TWI_MMR_IADRSZ_Msk);
     
139. 
     
140.         //设置远程芯片的内部地址
     
141.         p_twi->TWI_IADR = 0;
     
142.         p_twi->TWI_IADR = twi_mk_addr(p_packet->addr, p_packet->addr_length);
     
143. 
     
144.         //发送一个开始条件
     
145.         p_twi->TWI_CR = TWI_CR_START;
     
146. 
     
147.         while (cnt > 0) {
     
148.                 status = p_twi->TWI_SR;
     
149.                 if (status & TWI_SR_NACK) {
     
150.                         return TWI_RECEIVE_NACK;
     
151.                 }
     
152. 
     
153.                 //判断是否是最后一个字节
     
154.                 if (cnt == 1) {
     
155.                         p_twi->TWI_CR = TWI_CR_STOP;
     
156.                 }
     
157. 
     
158.                 if (!(status & TWI_SR_RXRDY)) {
     
159.                         continue;
     
160.                 }
     
161.                 *buffer++ = p_twi->TWI_RHR;
     
162. 
     
163.                 cnt--;
     
164.         }
     
165. 
     
166.         while (!(p_twi->TWI_SR & TWI_SR_TXCOMP)) {
     
167.         }
     
168. 
     
169.         p_twi->TWI_SR;
     
170. 
     
171.         return TWI_SUCCESS;
     
172. }
     
173. 
     
174. //将多个字节写入一个TWI兼容的从设备
     
175. uint32_t twi_master_write(Twi *p_twi, twi_packet_t *p_packet)
     
176. {
     
177.         uint32_t status, cnt = p_packet->length;
     
178.         uint8_t *buffer = p_packet->buffer;
     
179. 
     
180.         //检查参数
     
181.         if (cnt == 0) {
     
182.                 return TWI_INVALID_ARGUMENT;
     
183.         }
     
184. 
     
185.         //设置写入模式，从地址和3个内部地址字节长度
     
186.         p_twi->TWI_MMR = 0;
     
187.         p_twi->TWI_MMR = TWI_MMR_DADR(p_packet->chip) |
     
188.                         ((p_packet->addr_length << TWI_MMR_IADRSZ_Pos) &
     
189.                         TWI_MMR_IADRSZ_Msk);
     
190. 
     
191.         //设置远程芯片的内部地址
     
192.         p_twi->TWI_IADR = 0;
     
193.         p_twi->TWI_IADR = twi_mk_addr(p_packet->addr, p_packet->addr_length);
     
194. 
     
195.         //发送所有字节
     
196.         while (cnt > 0) {
     
197.                 status = p_twi->TWI_SR;
     
198.                 if (status & TWI_SR_NACK) {
     
199.                         return TWI_RECEIVE_NACK;
     
200.                 }
     
201. 
     
202.                 if (!(status & TWI_SR_TXRDY)) {
     
203.                         continue;
     
204.                 }
     
205.                 p_twi->TWI_THR = *buffer++;
     
206. 
     
207.                 cnt--;
     
208.         }
     
209. 
     
210.         while (1) {
     
211.                 status = p_twi->TWI_SR;
     
212.                 if (status & TWI_SR_NACK) {
     
213.                         return TWI_RECEIVE_NACK;
     
214.                 }
     
215. 
     
216.                 if (status & TWI_SR_TXRDY) {
     
217.                         break;
     
218.                 }
     
219.         }
     
220. 
     
221.         p_twi->TWI_CR = TWI_CR_STOP;
     
222. 
     
223.         while (!(p_twi->TWI_SR & TWI_SR_TXCOMP)) {
     
224.         }
     
225. 
     
226.         return TWI_SUCCESS;
     
227. }
     
228. 
     
229. //使能TWI中断
     
230. void twi_enable_interrupt(Twi *p_twi, uint32_t ul_sources)
     
231. {
     
232.         //启用指定的中断
     
233.         p_twi->TWI_IER = ul_sources;
     
234. }
     
235. 
     
236. //关闭TWI中断
     
237. void twi_disable_interrupt(Twi *p_twi, uint32_t ul_sources)
     
238. {
     
239.         //关闭指定的中断
     
240.         p_twi->TWI_IDR = ul_sources;
     
241.         //伪读
     
242.         p_twi->TWI_SR;
     
243. }
     
244. 
     
245. //得到TWI中断状态
     
246. uint32_t twi_get_interrupt_status(Twi *p_twi)
     
247. {
     
248.         return p_twi->TWI_SR;
     
249. }
     
250. 
     
251. //读TWI中断掩码
     
252. uint32_t twi_get_interrupt_mask(Twi *p_twi)
     
253. {
     
254.         return p_twi->TWI_IMR;
     
255. }
     
256. 
     
257. //从TWI总线读取一个字节
     
258. uint8_t twi_read_byte(Twi *p_twi)
     
259. {
     
260.         return p_twi->TWI_RHR;
     
261. }
     
262. 
     
263. //向总线上的一个TWI从服务器发送一个字节的数据
     
264. void twi_write_byte(Twi *p_twi, uint8_t uc_byte)
     
265. {
     
266.         p_twi->TWI_THR = uc_byte;
     
267. }
     
268. 
     
269. //使能TWI从模式
     
270. void twi_enable_slave_mode(Twi *p_twi)
     
271. {
     
272.         //设置主禁用位和从禁用位
     
273.         p_twi->TWI_CR = TWI_CR_MSDIS;
     
274.         p_twi->TWI_CR = TWI_CR_SVDIS;
     
275. 
     
276.         //设置主使能位
     
277.         p_twi->TWI_CR = TWI_CR_SVEN;
     
278. }
     
279. 
     
280. //关闭TWI从模式
     
281. void twi_disable_slave_mode(Twi *p_twi)
     
282. {
     
283.         //设置从机禁用位
     
284.         p_twi->TWI_CR = TWI_CR_SVDIS;
     
285. }
     
286. 
     
287. //初始化TWI从模式
     
288. void twi_slave_init(Twi *p_twi, uint32_t ul_device_addr)
     
289. {
     
290.         //禁用TWI中断
     
291.         p_twi->TWI_IDR = ~0UL;
     
292.         p_twi->TWI_SR;
     
293. 
     
294.         //复位TWI
     
295.         twi_reset(p_twi);
     
296. 
     
297.         //在从模式下设置从地址
     
298.         p_twi->TWI_SMR = TWI_SMR_SADR(ul_device_addr);
     
299. 
     
300.         //使能从模式
     
301.         twi_enable_slave_mode(p_twi);
     
302. }
     
303. 
     
304. //设置TWI从地址
     
305. void twi_set_slave_addr(Twi *p_twi, uint32_t ul_device_addr)
     
306. {
     
307.         //设置从地址
     
308.         p_twi->TWI_SMR = TWI_SMR_SADR(ul_device_addr);
     
309. }
     
310. 
     
311. //从主服务器读取数据
     
312. uint32_t twi_slave_read(Twi *p_twi, uint8_t *p_data)
     
313. {
     
314.         uint32_t status, cnt = 0;
     
315. 
     
316.         do {
     
317.                 status = p_twi->TWI_SR;
     
318.                 if (status & TWI_SR_SVACC) {
     
319.                         if (!(status & TWI_SR_GACC) &&
     
320.                                 ((status & (TWI_SR_SVREAD | TWI_SR_RXRDY))
     
321.                                  == (TWI_SR_SVREAD | TWI_SR_RXRDY))) {
     
322.                                 *p_data++ = (uint8_t) p_twi->TWI_RHR;
     
323.                                 cnt++;
     
324.                         }
     
325.                 } else if ((status & (TWI_SR_EOSACC | TWI_SR_TXCOMP))
     
326.                                         == (TWI_SR_EOSACC | TWI_SR_TXCOMP)) {
     
327.                         break;
     
328.                 }
     
329.         } while (1);
     
330. 
     
331.         return cnt;
     
332. }
     
333. 
     
334. //将数据写入TWI总线
     
335. uint32_t twi_slave_write(Twi *p_twi, uint8_t *p_data)
     
336. {
     
337.         uint32_t status, cnt = 0;
     
338. 
     
339.         do {
     
340.                 status = p_twi->TWI_SR;
     
341.                 if (status & TWI_SR_SVACC) {
     
342.                         if (!(status & (TWI_SR_GACC | TWI_SR_SVREAD)) &&
     
343.                                 (status & TWI_SR_TXRDY)) {
     
344.                                 p_twi->TWI_THR = *p_data++;
     
345.                                 cnt++;
     
346.                         }
     
347.                 } else if ((status & (TWI_SR_EOSACC | TWI_SR_TXCOMP))
     
348.                                         == (TWI_SR_EOSACC | TWI_SR_TXCOMP)) {
     
349.                         break;
     
350.                 }
     
351.         } while (1);
     
352. 
     
353.         return cnt;
     
354. }
     
355. 
     
356. //重置TWI
     
357. void twi_reset(Twi *p_twi)
     
358. {
     
359.         //设置SWRST位重置TWI外设
     
360.         p_twi->TWI_CR = TWI_CR_SWRST;
     
361.         p_twi->TWI_RHR;
     
362. }
     
363. 
     
364. //获取TWI PDC基址
     
365. Pdc *twi_get_pdc_base(Twi *p_twi)
     
366. {
     
367.         Pdc *p_pdc_base = NULL;
     
368. 
     
369.         if (p_twi == TWI0) {
     
370.                 p_pdc_base = PDC_TWI0;
     
371.         }
     
372. #ifdef PDC_TWI1
     
373.         else if (p_twi == TWI1) {
     
374.                 p_pdc_base = PDC_TWI1;
     
375.         }
     
376. #endif
     
377. #ifdef PDC_TWI2
     
378.                 else if (p_twi == TWI2) {
     
379.                         p_pdc_base = PDC_TWI2;
     
380.                 }
     
381. #endif
     
382.         else
     
383.         {
     
384.                 Assert(false);
     
385.         }
     
386. 
     
387.         return p_pdc_base;
     
388. }
     
389. 
     
390. #if SAM4E
     
391. //启用\禁用写保护模式
     
392. void twi_set_write_protection(Twi *p_twi, bool flag)
     
393. {
     
394.         if (flag) {
     
395.                 p_twi->TWI_WPROT_MODE = TWI_WP_KEY_VALUE | TWI_WPROT_MODE_WPROT;
     
396.         } else {
     
397.                 p_twi->TWI_WPROT_MODE = TWI_WP_KEY_VALUE;
     
398.         }
     
399. }
     
400. 
     
401. //简要读取写入保护状态
     
402. void twi_read_write_protection_status(Twi *p_twi, uint32_t *p_status)
     
403. {
     
404.         *p_status = p_twi->TWI_WPROT_STATUS;
     
405. }
     
406. #endif
     

复制代码