基于STM32F1的CAN通信之EEPROM(AT24C02)

[复制链接]

攻城狮Melo 发布时间：2023-10-23 20:34

文章
文章封面:
文章简介:	基于STM32F1的CAN通信之EEPROM(AT24C02)

一、AT24C02简介
AT24C01/02/04/08/16...是一个1K/2K/4K/8K/16K位电可擦除PROM，内部含有128/256/512/1024/2048个8位字节，AT24C01有一个8字节页写缓冲器，AT24C02/04/08/16有一个16字节页写缓冲器。电压可允许低至1.8V，待机电流和工作电流分别为1uA和1mA。该器件通过I2C总线接口进行操作，这里就不再对IIC做详细介绍了，具体可见外设系列OLED篇。

8 @$ k3 p9 i( j% B- e二、AT24C02引脚

AT24C02引脚定义

三、AT24C02寻址
使能芯片读写操作后，EEPROM都要求有8位的器件地址信息。

AT24C02地址信息

器件地址信息由"1"、"0"序列组成，前4位对于所有串行EEPROM都是一样的。对于24C02/32/64，随后3位A2、A1和A0为器件地址位，必须与硬件输入引脚保持一致。

四、AT24C02读/写操作, k( \9 {' p6 e) q2 d/ x+ k
4.1 AT24C02写操作
写操作要求主设备发送器件地址，收到应答信号后，先接收8位的字地址。接收到这个地址后EEPROM应答"0"（ACK），然后再是一个8位数据。在接收8位数据后，EEPROM应答"0"（ACK），接着必须由主器件发送停止条件来终止写序列。时序图如下

写操作时序图

24C02器件按8字节/页执行页写，24C04/08/16器件按16字节/页执行页写，24C32/64器件按32字节/页执行页写。页写初始化与字节写相同，只是主器件不会在第一个数据后发送停止条件，而是在EEPROMEEPROM收到每个数据后都应答“0”。最后仍需由主器件发送停止条件，终止写序列。

接收到每个数据后，字地址的低3位 (24C02) 或4位(24C04/08/16) 或5位(24C32/64)内部自动加1，高位地址位不变，维持在当前页内。当内部产生的字地址达到该页边界地址时，随后的数据将写入该页的页首。如果超过8个 (24C02) 或16个 (24C04/08/16) 或32个(24C32/64) 数据传送给了EEPROM，字地址将回转到该页的首字节，先前的字节将会被覆盖。

$ R* e' @# ?6 A B
4.2 AT24C02读操作
AT24C02的读操作有三种，分别是当前地址读，随机读和顺序读。
• 当前地址读内部地址计数器保存着上次访问时最后一个地址加1的值。只要芯片有电，该地址就一直保存当读到最后页的最后字节，地址会回转到0。当写到某页尾的最后一个字节，地址会回转到该页的首字节。接收器件地址(读/写选择位为"1") 且EEPROM应答ACK后，当前地址的数据就随时钟送出。主器件无需应答"0"，但需发送停止条件。当前地址读操作时序图如下

读当前地址时序图

• 随机读随机读需先写一个目标字地址，一旦EEPROM接收器件地址和字地址并应答了ACK，主器件就产生一个重复的起始条件。然后，主器件发送器件地址(读/写选择位为"1") ，EEPROM应答ACK，并随时钟送出数据。主器件无需应答"0"，但需发送停止条件。这里的随机读就是读取任意一个字地址的数据，并不是随即返回一个数据的意思。随机读时序图如下

随机读时序图

• 顺序读顺序读可以通过“当前地址读”或“随机读”启动。主器件接收到一个数据后，应答ACK。只要EEPROM接收到ACK，将自动增加字地址并继续随时钟发送后面的数据。若达到存储器地址末尾，地址自动回转到0，仍可继续顺序读取数据。主器件不应答"0"，而发送停止条件，即可结束顺序读操作。顺序读时序图如下

顺序读时序图

五、AT24C02程序
这里给出一个AT24C02的程序，仅供参考

/*******************************************************************************
8 `. w" l5 C& W
* 函数名 : IIC_Init5 |; G) Q: s1 T9 t. ~
* 函数功能 : IIC初始化
$ z& c& [" d' }: W8 f' Y+ T
* 输入 : 无9 Y- d# U4 U3 F, Z
* 输出 : 无
2 Y" g+ n: g7 M! R" Z; Y6 h
*******************************************************************************/0 [4 x+ T4 k' W. g4 ?; h; |% g2 p
void IIC_Init(void)) Q$ v" p, E. X
{
8 y' d6 g, O: R& ~( `
GPIO_InitTypeDef GPIO_InitStructure;
- h! g7 x" y; H
RCC_APB2PeriphClockCmd(IIC_SCL_PORT_RCC|IIC_SDA_PORT_RCC,ENABLE);8 K4 y% l# Y2 t5 S1 d
) i" P* v9 _# n8 L, q2 \1 S, w) n
GPIO_InitStructure.GPIO_Pin=IIC_SCL_PIN;
7 r- J, h1 \5 Q5 ~3 B6 X5 V4 P
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;: M0 G- q& ]; @+ `, l/ ^8 `
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;5 j5 J0 l. c% b2 b; K, q1 \0 `' r
GPIO_Init(IIC_SCL_PORT,&GPIO_InitStructure);
' l+ p$ k, }" |& U/ V
, N4 i$ Z+ A W
GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;
+ N( b& w( v" y" ~
GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
6 l! P5 p8 }! p$ r2 j* Y( ? v
- S; E, z4 i, J) G4 |" o' q7 ?/ g
IIC_SCL=1;; O7 t; k1 J0 d0 R _' \: a' H8 N% J
IIC_SDA=1;
& m- q: P: f4 ^/ ]" A& o. _
}4 U7 Z# a6 b& D. [6 e
/*******************************************************************************
$ p0 G+ Y8 _2 C- C/ c1 y
* 函数名 : SDA_OUT7 Z: y5 Z" j7 Z8 D# B
* 函数功能 : SDA输出配置
2 p5 f" Q9 p/ @: R9 y+ f
* 输入 : 无
: M! w/ Z2 Q/ J! p2 q% K6 h% B
* 输出 : 无
' f/ K5 z) d/ M1 z; M
*******************************************************************************/
/ z# c1 f6 \4 p: ]
void SDA_OUT(void)
0 t# ~1 _8 u- Y" `% k& ~2 N4 r
{) Q' i9 ?1 k" z, J
GPIO_InitTypeDef GPIO_InitStructure;9 B( B; P$ t& y1 P- u
; Z" F. s2 h6 M e* _8 G
GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;! N+ O/ K( \5 @! d4 d* C/ B7 |2 `
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;* ^ i9 W1 Z* C% M
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;- {8 k' i5 C% h' E; y6 ?/ c5 r
GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);, ~, I: ]3 |* V/ g6 h
}) r; C( p1 V3 q6 d* r9 A
t$ V$ } W, E1 d
/*******************************************************************************
v5 o% J0 d! P: j2 |6 H
* 函数名 : SDA_IN. W; \1 T1 r# `# }# I9 D3 G
* 函数功能 : SDA输入配置
2 K6 X/ { [1 I" p% m/ L2 I/ k
* 输入 : 无
* _9 R/ ?2 B8 o1 C$ O5 k) o
* 输出 : 无- |3 Z* ^5 \: h/ H
*******************************************************************************/
2 `) }: i1 W5 r+ x! t
void SDA_IN(void)
4 R9 k9 R, B) ]% j+ Y) ]+ A
{
6 ^) H% a3 V9 ?3 u
GPIO_InitTypeDef GPIO_InitStructure;; R) O$ K% B, _. I8 @
+ l2 J' ^, b7 P+ M2 W
GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;9 F8 J& ]$ l6 E+ h8 A w
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
1 W$ t2 t1 }5 n
GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);) m, i8 g, }' X6 P& u/ g
}
, r9 L/ l0 F* n! o7 g; Z" V) b2 d
- `* F/ i* j' R, M& P! k
/*******************************************************************************
7 T% o' E- B0 y1 W" v; [: v# M) n# o
* 函数名 : IIC_Start
, a0 K6 Y' V j& ~& V
* 函数功能 : 产生IIC起始信号
2 y0 O. f( a0 Z: v
* 输入 : 无
9 R/ S9 B x9 j7 X; _5 V6 T4 |
* 输出 : 无( J* c; C3 g& v3 z4 T: l" p
*******************************************************************************/
, a1 k* I% Z& ?' K; X: {
void IIC_Start(void)$ o) K4 B0 x6 q) P" ?" i9 A
{" o6 d! `# L( _; ^
SDA_OUT(); //sda线输出
) Z" e9 _ p5 N9 P! U W6 ]- S: U
IIC_SDA=1;
, |3 a( x3 k7 K9 Q
IIC_SCL=1;
2 F9 d' b, `, B: H
delay_us(5);7 u/ ?5 ~1 e1 @; O' B) {# [
IIC_SDA=0;//START:when CLK is high,DATA change form high to low 0 z# Q# a) A* k; r# A, s
delay_us(6);
7 G* [6 f- n9 e4 c
IIC_SCL=0;//钳住I2C总线，准备发送或接收数据 ! ]* O0 F( `, p- w; Z7 Y2 T9 I
}
! c3 B6 u. j$ ]( D
1 K% [2 {. Y5 y* P
/*******************************************************************************
+ x: E+ U, v( _# L7 a3 W$ H' v
* 函数名 : IIC_Stop4 m& \! v$ G( [1 N& W
* 函数功能 : 产生IIC停止信号 " c( l4 Y+ i9 I+ Q
* 输入 : 无
/ p( `* B& c: P+ V' k4 L( m8 P
* 输出 : 无$ M6 V# I) B. ~2 s6 [& j! u' }) M
*******************************************************************************/) T/ ~! z) v0 E6 r% q* c9 p
void IIC_Stop(void)0 s4 |5 }: Y* E. o% i5 c! s
{
- Y5 G7 M2 p" P, Z ^2 z" N
SDA_OUT();//sda线输出7 s# y7 H" s% o" \$ N" K* l$ X
IIC_SCL=0;2 Y. @. u2 X+ \+ ^& ?/ w9 Y
IIC_SDA=0;//STOP:when CLK is high DATA change form low to high0 e3 H+ B0 j7 I9 x* U! ]8 m( |' N
IIC_SCL=1;
, E8 k. S8 u8 g5 A' \
delay_us(6);
0 f; t$ l1 J5 z4 j4 y
IIC_SDA=1;//发送I2C总线结束信号
( i0 u% U/ n2 w; R+ F r, g
delay_us(6);
: o# I# ~+ S0 j5 E+ z+ ^7 G
}3 E* N0 K2 _, ^7 h" L# [
* q! }0 o, o o K" i
/*******************************************************************************
! Q1 }: H( ~2 ^5 A: U
* 函数名 : IIC_Wait_Ack
4 z, |, Z1 O- c0 F; ?5 k7 D6 |9 v
* 函数功能 : 等待应答信号到来 ' Y0 L X l2 ]( i/ n3 z6 H
* 输入 : 无 i( f+ C0 w( ?& [; S2 v
* 输出 : 1，接收应答失败
% t% q. @0 L- c
0，接收应答成功
) r' I7 J0 U9 ?( Q* l. I
*******************************************************************************/
- e4 N( [# J( j5 a3 H$ ]
u8 IIC_Wait_Ack(void)2 K# \/ m6 j$ q
{% Z9 z4 J$ @1 b$ [+ C, }3 z
u8 tempTime=0;
8 L. w0 } x# w6 K8 S8 ?( [
SDA_IN(); //SDA设置为输入 2 q/ [/ ~# r( g
IIC_SDA=1;
$ Y0 b3 a0 \6 {
delay_us(1); 2 E( C0 ^, \3 f8 ^" Z
IIC_SCL=1;
/ ?7 z+ j& E6 p
delay_us(1); - ]* ?$ H2 E6 ~4 \
while(READ_SDA)
9 q4 ~; }% x1 G' V: C4 K3 r% \
{( Q9 D& T( ^0 W( `- V; j
tempTime++;
' Z- q& p; }9 f: [/ c
if(tempTime>250); t) @, Y, H3 {. ~: W! p
{
0 P7 Z7 j6 g. B$ Z2 i
IIC_Stop();& U9 C% X) M7 Q
return 1;3 m; T e4 u% N. n
}0 e( Z3 j+ c' _0 O+ S
}
* o6 ~+ m0 R+ S( ^: ~* `* p! }( B* m% ]
IIC_SCL=0;//时钟输出0
4 Q- U$ B/ A) w: }
return 0;
! P5 _+ s/ G4 L% |
} 5 r B+ }0 S" i! J
9 h" Q2 t: ?# p4 z7 c. p
/*******************************************************************************4 }1 n% ?1 R6 f4 S) d7 o9 |, S
* 函数名 : IIC_Ack
: x: [4 ]0 }9 C8 ?
* 函数功能 : 产生ACK应答 8 k2 x k1 ]" F5 `. w& \, {: {6 S
* 输入 : 无
4 e' t& _1 A ]$ K% @$ |9 j0 H# e1 @
* 输出 : 无
, K! ~/ O! Z0 J6 Z
*******************************************************************************/$ l6 J9 M! }1 y7 w; R
void IIC_Ack(void)/ s% z& q' w6 q- Z+ @5 ^: m- r4 w
{* }0 U, w: F$ n4 K/ k
IIC_SCL=0;
( ]) I( R' r' M3 l% |/ m
SDA_OUT();
/ v* f) Q D( M7 o
IIC_SDA=0;. z6 g6 _* D+ X1 C0 O
delay_us(2);
4 E0 D l$ Z1 F
IIC_SCL=1;
1 D; p4 v7 s8 N8 e( o# }8 e, q! X
delay_us(5);+ {" t$ I3 k/ e X* h9 a
IIC_SCL=0;4 \8 h) R, ^+ j- n% p
}
9 [( W# H; P# l( m
8 K& b0 |0 P) I# Z: K! x: x
/*******************************************************************************/ |8 Z* d' c$ S; J9 j. e$ v" Q
* 函数名 : IIC_NAck
6 d, x, Z+ G U& V5 y8 L- ~
* 函数功能 : 产生NACK非应答 , \7 I1 {. |: D$ g" z7 x
* 输入 : 无( a/ w) P9 K% h
* 输出 : 无0 O% d( G) l7 t2 q5 ?; G- n
*******************************************************************************/ 6 o9 J8 M0 e" a( L8 q" G. Y
void IIC_NAck(void)
# Q1 Y, L" N4 G/ f1 \0 T
{
. n" u4 X% O0 } w
IIC_SCL=0;
! [/ F3 k J6 Q- j' N/ {& T
SDA_OUT();- Y- N$ F: G1 l) T
IIC_SDA=1;$ R2 H* @2 G# u k6 c
delay_us(2);- _; q, S! ~+ \
IIC_SCL=1;
* m# n& w8 F9 a% I
delay_us(5);# u( ]1 K% B, a6 |+ a( \
IIC_SCL=0;
! I' E5 |# e! M/ p" ^8 n1 I' M
}
* i+ g: B; p- {. v$ d
4 x- t8 T+ `3 r5 C6 t1 X+ q/ c
/*******************************************************************************$ e) C( U6 u" p3 r$ t8 R
* 函数名 : IIC_Send_Byte
. {3 J$ P( p$ D3 o4 Z" K
* 函数功能 : IIC发送一个字节
; U' x0 f" z9 S! @* R- U
* 输入 : txd：发送一个字节
0 Q" I. {: }3 }# P+ x' P. E
* 输出 : 无
# G$ w. U4 I. H3 a0 \, x, L
*******************************************************************************/
3 b2 K" t; v' V3 M+ U
void IIC_Send_Byte(u8 txd). F) o6 l7 b1 t2 a! `" M" C; `) p
{ & g1 s) N& p% p1 o; r2 |
u8 t;
1 H: G7 u+ Z6 R( S- ]
SDA_OUT(); / c0 S" Y) |+ ?# c
IIC_SCL=0;//拉低时钟开始数据传输1 ~, ^" S/ ~& P- g! s; J* ^
for(t=0;t<8;t++)
. n7 d+ u; s# Z# l! t/ L! S' Z4 T$ ~
{
0 }% {6 m/ Y. k
if((txd&0x80)>0) //0x80 1000 0000
+ M0 V$ ^! `1 N& ~: k% J
IIC_SDA=1;
9 Z: l2 D% C: V5 d" C
else
/ L5 h% i2 P) Z- f! B
IIC_SDA=0;
( {0 d' m/ z; W+ r# f |
txd<<=1;
' u& l) I J5 a
delay_us(2); //对TEA5767这三个延时都是必须的
, J8 R X; B1 @9 P- ]: n8 T6 m
IIC_SCL=1;2 T* E2 H4 M. Z/ C) ?( ]5 ]3 a8 ?; w
delay_us(2); ! C4 E8 u1 s/ U$ h
IIC_SCL=0; 4 Z R6 n# q, x# R6 K
delay_us(2);
8 P* D+ c) {& V$ B: ~3 b
}
( u% e9 [8 C9 M$ j% C
} & g) w+ ^, }7 `1 t8 G$ t
( ?' X, P: l9 J# r) O" w
/*******************************************************************************: ~+ B6 e: T) |- ^5 V
* 函数名 : IIC_Read_Byte
. T% `) k2 B' d% A7 X6 t
* 函数功能 : IIC读一个字节 2 N h; W* {/ q. Y. V, D- ~8 y0 T
* 输入 : ack=1时，发送ACK，ack=0，发送nACK
1 r# s8 }# A [
* 输出 : 应答或非应答
! a1 ^2 B8 i+ z/ l8 J7 ?
*******************************************************************************/
9 q" Y* a M& Z9 w6 A" Z" \! r; y, B
u8 IIC_Read_Byte(u8 ack)+ q3 p+ R; M% \" X% E1 v
{9 }4 b1 f; [" t& g6 u
u8 i,receive=0;
5 q8 J2 X5 A+ g3 ~+ r
SDA_IN();//SDA设置为输入
$ s7 [0 X2 S5 R) i0 _( D& \
for(i=0;i<8;i++ )
# `3 K g8 d5 g
{7 d" D- U& J4 L) ~$ O
IIC_SCL=0;
) G# f! R8 w N7 Z2 X% O% p1 R
delay_us(2);
6 s' G* ~! K# T4 X3 ?: `+ O
IIC_SCL=1;2 O6 V, z. Q" `, P! ?
receive<<=1;
- y1 }; ?, d3 u/ i1 p% h
if(READ_SDA)receive++; 5 h" X) N+ ?& v/ O3 m1 c: U
delay_us(1);
3 V$ i* G0 ]6 [" I! _% ?
}
5 _: e+ S6 Q7 } ]4 P* ^
if (!ack)
. k7 o6 B( H' ~3 O M# x4 B
IIC_NAck();//发送nACK8 D' s! {# r$ l5 H: Z9 v
else9 L! _3 h/ P( t* w2 C
IIC_Ack(); //发送ACK + J2 |: u; I6 Z' f3 G4 \
return receive;) S4 Y; B% x6 u% L& F; _
}' c+ a: @& V- y' ]* j" {/ ?
/*******************************************************************************
% Y( P/ S" x) a9 ^
* 函数名 : AT24CXX_Init2 s- z7 Q) { u5 r* ^! c
* 函数功能 : AT24CXX初始化, }* s( i7 o, S. D
* 输入 : 无$ _! p: e& K$ Q
* 输出 : 无
' ]- O6 f3 V8 H) k! v5 ?, _
*******************************************************************************/& n& O5 ^- V+ T" c0 R6 W
void AT24CXX_Init(void)! i( p1 o& h7 @" I" Q0 u8 S
{
8 z! D1 \" ?3 T. C/ b9 z
IIC_Init();//IIC初始化0 x0 c. b. T' s$ j/ _8 X8 r
}- F$ J$ j& p S: @# _
, P. L2 A/ a! ?% W- K" }
/*******************************************************************************
$ m+ F8 i" L' Y( @- ]2 p) X4 A- P
* 函数名 : AT24CXX_ReadOneByte
. {* B% U( y$ W% H& P
* 函数功能 : 在AT24CXX指定地址读出一个数据
+ S/ B$ T q0 I8 X! s+ ~8 f) H
* 输入 : ReadAddr:开始读数的地址
; M! _- ~4 `& \: P( W# l: J
* 输出 : 读到的数据7 Q: R3 q+ ^# M; P2 u1 d1 S
*******************************************************************************/! n" S8 l' V8 X' d
u8 AT24CXX_ReadOneByte(u16 ReadAddr)& H( U) R0 R4 M* o
{ # `, u8 X! U2 W D' E
u8 temp=0;
* I6 Z0 m8 v0 g; t7 x
IIC_Start(); - l7 ]% k/ e4 `8 X1 v$ e% F3 t( g, }
if(EE_TYPE>AT24C16)
4 U/ I6 u( f+ P" Y' V% Z
{ z x( y0 \! ?+ L$ G
IIC_Send_Byte(0XA0); //发送写命令
; w" v8 V8 t B
IIC_Wait_Ack();
( V9 @5 s3 q4 ?% S
IIC_Send_Byte(ReadAddr>>8);//发送高地址
8 F: [* l/ U6 W4 Z9 ^
}
; F4 W: ~! O. _( Z
else
3 {0 B6 f0 _- j, d
{$ F0 f6 W' R0 r! L! Z' c
IIC_Send_Byte(0XA0+((ReadAddr/256)<<1)); //发送器件地址0XA0,写数据' {1 X" b2 `& z
} % b& d2 y3 o" \9 v0 _& u
IIC_Wait_Ack(); ; s! h( U, z* W- }+ B: d% a
IIC_Send_Byte(ReadAddr%256); //发送低地址4 n z# K, F5 D3 A% F
IIC_Wait_Ack();
' @* N4 O4 x1 M' p* @3 J" l+ c
IIC_Start();
9 I) S! p4 K8 @; F
IIC_Send_Byte(0XA1); //进入接收模式 ' b6 f1 R# ]6 a7 t" n4 w
IIC_Wait_Ack(); 2 j8 D e4 h$ `" k2 t) P/ I
temp=IIC_Read_Byte(0);
' \" |) i+ u! P* t" U2 H2 ]* P7 R
IIC_Stop();//产生一个停止条件 - r; h, t7 j+ w
return temp;
7 n4 E0 | R; f, Z9 _/ w3 F& Q
}
6 f. x& N. Y* G! m' g( ]# P
5 v. ~( @& \) Z2 V5 W& t* R
/*******************************************************************************
6 _, K) I3 W% F# `0 k- N: E' w1 _
* 函数名 : AT24CXX_WriteOneByte
% {, P: ]! m. z$ c
* 函数功能 : 在AT24CXX指定地址写入一个数据
# V4 b" x6 \1 q, \# M
* 输入 : WriteAddr :写入数据的目的地址 3 e2 I7 b3 ]0 D2 o0 [5 T. r9 o
DataToWrite:要写入的数据9 _! [2 |, n5 ?/ F$ d& [2 z# y1 E
* 输出 : 无, J( C A/ ~4 N% H7 s& H
*******************************************************************************// @; v7 z, {; x8 i O; Z% r
void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
% ^! `( h. J* ~. r4 h, K8 s" |
{ % o8 q$ w+ w% ~/ M# B
IIC_Start();
9 ]) l) D' ? N$ _5 N! p; h. Y
if(EE_TYPE>AT24C16)
5 }; |; S# V% W4 U! `) G
{
! Y1 x. J' I0 [ X/ A4 @* c
IIC_Send_Byte(0XA0); //发送写命令
4 {+ Q* g# |% P' e1 }" c2 \2 z' g9 r
IIC_Wait_Ack();
Q( n2 {+ e& i3 [5 Q3 P
IIC_Send_Byte(WriteAddr>>8);//发送高地址
/ E& L7 ]0 D' Y* Q5 ~% E
}
% v- ?) Z6 c/ C+ T9 A
else ' J, e1 p; a0 j( b
{0 s8 H% F6 H4 [" N% @7 a
IIC_Send_Byte(0XA0+((WriteAddr/256)<<1)); //发送器件地址0XA0,写数据7 p8 M7 x. y+ v: o# w' J* ` k; U
} 3 ^1 K1 z5 x" S" U& V
IIC_Wait_Ack();
: P8 [2 Q! I/ L; f' H" T9 q
IIC_Send_Byte(WriteAddr%256); //发送低地址
% L/ u; P/ [0 R5 M
IIC_Wait_Ack(); ! e+ R( ?2 B/ X+ s( K
IIC_Send_Byte(DataToWrite); //发送字节
- V8 x( i! ~2 s% ^; |# A- s9 {& J
IIC_Wait_Ack(); 0 M) k2 I1 m/ o) F& }' C2 p5 S- t4 ?6 Y
IIC_Stop();//产生一个停止条件
: n7 Z: \) o) h$ R3 ~
delay_ms(10); 8 [2 C& [6 R9 z) X* s7 c
}$ ~9 L' o5 c! j) s: L, ~5 z/ K
& |# Y/ k" x: n8 m" w* h# w- H! L
/*******************************************************************************
& c$ q- J! e( B# g
* 函数名 : AT24CXX_WriteLenByte; s) r2 N* u) @+ i1 S- q$ O, a
* 函数功能 : 在AT24CXX里面的指定地址开始写入长度为Len的数据
$ f: z; f. n; \$ {' Z$ L1 ?, @
用于写入16bit或者32bit的数据
F* `: y. d; x' h, s, I
* 输入 : WriteAddr :写入数据的目的地址 2 W% U8 S8 Y9 K6 h
DataToWrite:要写入的数据% c, A8 m, D! k4 y5 D5 |
Len :要写入数据的长度2,4
% g3 T% `* k0 V) a3 i( j
* 输出 : 无
2 | O5 T7 K. o6 m0 Y; _! n- F
*******************************************************************************/
, L/ B+ ]. Y" W6 Q7 P
void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)9 E% G+ S2 ^9 g* t
{ + ]+ p8 j. E( u7 `# p7 U
u8 t;, f' m; [2 A1 ~7 u% H9 l D+ I
for(t=0;t<Len;t++)
7 ^3 `8 H x; w; T/ K+ B
{# y4 i2 B- M6 L! V
AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);% q0 r L }( n% {7 I j0 [+ S
}
' Y, Z6 _% M0 ^2 L/ l8 w
}; L5 r; O8 t) O/ C$ \/ k
! i5 t" E( s( t1 t0 s( ]
/*******************************************************************************
) w- ?- O8 \- S1 w* q) A
* 函数名 : AT24CXX_ReadLenByte
) j! r* E6 y2 ]0 D& @
* 函数功能 : 在AT24CXX里面的指定地址开始读出长度为Len的数据
7 f" l3 l# f3 G. X6 J- g" }7 [7 p
用于读出16bit或者32bit的数据) s! s& R( T" R
* 输入 : ReadAddr :开始读出的地址 4 \. S6 U2 h6 a2 v
Len :要读出数据的长度2,4
- G5 `, @9 e8 `* O# t( G8 s
* 输出 : 读取的数据, l; s4 d' L$ o! \: b! } a9 {
*******************************************************************************/4 h- \1 T& O0 {% W( F& c5 u/ u
u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)4 A7 I5 V) q q/ V% w" }& W
{
1 T D3 q: W; z$ z; @% Z
u8 t;3 ]7 k; B$ H9 F6 B( w
u32 temp=0;3 e8 R, M: D a d; N& I
for(t=0;t<Len;t++)
6 j) M/ `' |5 U* ~$ Y! C
{# r8 H4 y2 |% M& Q. o5 H# w2 @6 V
temp<<=8;
# Y5 _! H' N; t, [5 W8 Y* r: v, a
temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);
7 H* p, @3 C( X& ~, b4 N
}
/ @* L# W5 }- R
return temp;
' m H+ r! f7 \2 q( L; g$ W% ^4 \
}9 T& `, F: o ^8 W# F5 ?( U
b' b3 f% \, c* N. O
/*******************************************************************************
9 y( u1 \1 @% r5 y( f& {- J9 o
* 函数名 : AT24CXX_Check6 O* l: \- Y; z
* 函数功能 : 检查AT24CXX是否正常
* Z+ i/ ?& L, c, ?' F2 F, U
* 输入 : 无
) m; M0 Q& m6 B( w% q
* 输出 : 1:检测失败，0:检测成功) v9 P+ f* A9 u; ~5 [
*******************************************************************************/
! ~# B- p0 t5 K! L i: i
u8 AT24CXX_Check(void)! a- m9 G; P, x
{
2 O1 y" i8 x+ s4 S2 d g
u8 temp;
8 i$ C! ^2 s" a3 w0 f) ], G0 @! U
temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX ~) F( r* q) V& z$ n+ P. b* B2 i9 m
if(temp==0x36)return 0; 9 R6 }# t1 z1 f% L, W# i1 \; l
else//排除第一次初始化的情况" f1 G- l x- N, j6 P' P8 K: m' }
{+ E1 ?0 F3 @4 Y& w# b3 @
AT24CXX_WriteOneByte(255,0X36);! x+ ~' v+ h5 f. q4 ^4 j
temp=AT24CXX_ReadOneByte(255); 6 X3 q& W# A& Q `7 w" p
if(temp==0X36)return 0;
$ B# M, c( v! u/ K. @
}
# |9 ]2 j" G8 \) q- v2 O8 g! s
return 1;
9 f+ N* h" Q$ P, X
}$ w) Y# L5 z r- U2 R
5 }, l7 `1 d# Z( |# O' B4 G/ S$ x0 b
/*******************************************************************************; D: C! W1 l9 C: O5 b `/ |& Y
* 函数名 : AT24CXX_Read% s0 U5 |. A) `7 ^
* 函数功能 : 在AT24CXX里面的指定地址开始读出指定个数的数据
4 E+ X8 A* h3 r2 J
* 输入 : ReadAddr :开始读出的地址对24c02为0~255; @% L, T) i2 U' g6 D: n2 E4 a
pBuffer :数据数组首地址
& ~7 u8 y4 q" e- g7 ~
NumToRead:要读出数据的个数
5 p' F8 f/ V9 v7 ]) J+ y: p
* 输出 : 无
, O- R- N' u8 k
*******************************************************************************/3 z5 l8 L% Q+ K0 n4 h. p
void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
' l ?: o" C6 O# \. T4 e$ B
{' Z' B/ E e L5 L; R: S9 m
while(NumToRead)
% Z! ?& t/ d- ]
{
& e! N* I3 c6 T: w/ B- V
*pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
7 g9 ~2 t+ y7 d" P8 Y+ P* _/ m7 \
NumToRead--;' w8 i- w* ^+ w) [1 g
}- ^/ U0 \) U4 G4 a
}
4 A- C7 _( m8 y
$ ?/ @" Y Q- C7 e+ I( A
/*******************************************************************************
; J# a4 X1 G1 ] G+ ?
* 函数名 : AT24CXX_Write! L2 O |1 H. g8 W+ j0 Y# z: W _
* 函数功能 : 在AT24CXX里面的指定地址开始写入指定个数的数据+ Q9 r: D' N5 o3 t& i
* 输入 : WriteAddr :开始写入的地址对24c02为0~255
4 s9 w9 S, z, p
pBuffer :数据数组首地址
) g5 F/ Z- A) V
NumToRead:要读出数据的个数
, H. V/ @9 f1 b/ B; x/ v
* 输出 : 无
, W( W- `5 y9 X3 d
*******************************************************************************/
, n8 i, e9 c7 ~- |$ J% _
void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
3 \" M; R& H* a5 H* O+ n$ U
{! ~' C* \( q: R# @4 D, D
while(NumToWrite--)* v! Z: n3 A* m' g2 x1 k) j
{; W9 [* q' A3 [
AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
* a) o2 g8 a; W1 O* f2 L
WriteAddr++;
" W, m G# s! z: ~0 S; `" r8 g( B
pBuffer++;- V* _0 k- ^- A4 N [
}
9 Q1 }# d: B& N' o& ~! L
}
+ [/ _" q) ~& ]" \% x4 F( v
.h文件如下
* Y' a) |5 m' @1 L8 Y
0 Y9 }0 t/ F8 G) D9 x% M; Y8 r
// 核心板使用的是24c02，所以定义EE_TYPE为AT24C024 o* u3 @# u0 l/ L2 p$ @$ b
// 可修改成AT24CXX系列中的任意一个
7 z% f4 z/ V+ V7 Q2 k% T+ ]$ y( l
#define EE_TYPE AT24C02
9 I* ], Y5 L# }0 y
$ U4 p5 a B2 Z" Q+ z7 g
// IIC函数" k3 ?/ j( d; _
void IIC_Init(void); // 初始化IIC的IO口
* j- L1 W; s, L/ c
void IIC_Start(void); // 发送IIC开始信号
8 d2 @7 G( I% B7 i9 O) o! F
void IIC_Stop(void); // 发送IIC停止信号
; J% [" ^; f3 ~! L7 K4 d
void IIC_Send_Byte(u8 txd); // IIC发送一个字节
' P# f+ r0 i- v% ~, @: h% j
u8 IIC_Read_Byte(u8 ack); // IIC读取一个字节* |# T4 s9 E) i/ i* ?$ X
u8 IIC_Wait_Ack(void); // IIC等待ACK信号% N4 @2 t+ C( Q6 @& h& z( m
void IIC_Ack(void); // IIC发送ACK信号
% w/ d1 E' I3 o& {' d0 Z2 O
void IIC_NAck(void); // IIC不发送ACK信号
' i. P3 \+ ~5 @) J' }; `
2 O( Y: q. q I- v1 C1 D
u8 AT24CXX_ReadOneByte(u16 ReadAddr); //指定地址读取一个字节
4 F" j# j$ R1 P
void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite); // 指定地址写入一个字节
/ `# [5 _) v7 p
void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len); // 指定地址开始写入指定长度的数据
: m& Q) u2 K9 e, `
u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len); // 指定地址开始读取指定长度数据0 ~3 w* ~# P2 n4 [
void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite); // 从指定地址开始写入指定长度的数据
0 ^, F$ m( z( e8 B9 O7 [/ J% A
void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead); // 从指定地址开始读出指定长度的数据5 |, q/ v/ h, t% Y
: B$ I1 y4 t7 h# W0 b
u8 AT24CXX_Check(void); // 检查器件
: Q8 T; |$ Y1 Q+ m! r2 Q% k' |. u! E
void AT24CXX_Init(void); // 初始化IIC