基于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篇。

' \* M! S1 r5 b& V二、AT24C02引脚

AT24C02引脚定义

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

AT24C02地址信息

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

四、AT24C02读/写操作
3 F' p& U& I0 ?) e- Q8 S" ?% {' V! s4.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，字地址将回转到该页的首字节，先前的字节将会被覆盖。

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

读当前地址时序图

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

随机读时序图

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

顺序读时序图

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

/*******************************************************************************
' X. @( ^$ d5 }% A! r" {* n3 j
* 函数名 : IIC_Init
7 `9 k& _# }2 O+ m
* 函数功能 : IIC初始化
% C5 M4 l Z; e( j2 T+ U
* 输入 : 无1 Z: g J3 C1 X+ b# `
* 输出 : 无0 x& ]% w7 H$ n$ i" U& i$ g
*******************************************************************************/1 P# D" v& Y" I7 P& G8 D
void IIC_Init(void)5 a" |2 l2 Z1 k2 j0 }, F, \
{
' o; G$ A9 a A& t2 X
GPIO_InitTypeDef GPIO_InitStructure;
/ x* ?# H' e3 e# \: V @ W) g
RCC_APB2PeriphClockCmd(IIC_SCL_PORT_RCC|IIC_SDA_PORT_RCC,ENABLE);
! u/ W- v6 ~$ k+ s/ a2 b: {3 M2 K; d
; d' e6 u+ K( }* k+ i# @$ E& q$ Y
GPIO_InitStructure.GPIO_Pin=IIC_SCL_PIN;$ H# Q; ]3 X. V2 D( M$ M
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;' C) e* M ~6 W* [4 W) ^8 i$ }; [$ @
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
: j" V% y! u/ c8 k
GPIO_Init(IIC_SCL_PORT,&GPIO_InitStructure);) \* [0 U+ U3 R5 D0 E
9 X; B8 a1 c& a/ x
GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;! D. S T- w" K. Q0 T& a R; ^
GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
! O7 L; u( u* M& }& Q/ p
& h2 h6 M+ X0 F6 x# H
IIC_SCL=1;7 e( U; s5 z8 }0 z: s4 w- P
IIC_SDA=1;
0 T6 l$ V3 i5 X- g c! }( d
}: Q& y+ \* _- t
/*******************************************************************************
# x$ v, @7 X4 Q9 f6 E4 b1 @
* 函数名 : SDA_OUT
, V0 ?; Z7 L& I4 f6 W* n
* 函数功能 : SDA输出配置
. v3 r" s/ }% p& o% D9 b
* 输入 : 无
7 I+ X, ^ \/ m2 A6 g' @% ]
* 输出 : 无
/ u/ M' G- R/ w
*******************************************************************************/! |) `9 c/ [: x! ^' S: I# ] }
void SDA_OUT(void)
$ K* D" T' e' u4 i4 i# r9 R
{
9 a) q: \$ G( F! f
GPIO_InitTypeDef GPIO_InitStructure;7 W5 C) e9 ^3 |) [: j
: o* ]: ]" |- H) K/ M
GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;# Z9 S/ J* Y8 b/ }- H& c3 o
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;0 t9 d$ D. G0 V1 d1 u
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
I& f; i0 {( t7 L
GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
8 I0 e3 m8 S% v: C3 K
}: F5 c3 r8 a- I) x* s! T6 h7 }) z
. A$ }# ]3 ~- k) r; R
/*******************************************************************************, v( ?: I- W# l- n1 t) m, @9 S$ }7 l
* 函数名 : SDA_IN# X% N* m& F& \7 U6 g9 Z
* 函数功能 : SDA输入配置
6 D6 h0 b) M5 k! n% Z
* 输入 : 无) e8 ~( L1 ^- i/ O$ D- V- o
* 输出 : 无
3 x3 @' d% E9 r: V1 t7 o; [
*******************************************************************************/
6 }9 f( e+ W# @/ {7 K6 `4 d
void SDA_IN(void)
5 }7 N* B* k) k; i% u
{* H0 t1 h5 `, z& I0 G% H$ L
GPIO_InitTypeDef GPIO_InitStructure;
$ b& U. n1 |6 D3 o# ^$ c9 ~
3 C b1 g* d0 C6 S: D; Q
GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;5 h' C0 g( j7 s) ]. R& v( |$ N- W
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;4 B: L( p2 T g2 s+ D
GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
" `( Y" r; @% M9 ~# J% p8 }
}
" ?8 r3 z! [5 I7 H
9 | a! z6 a5 w8 s
/******************************************************************************* H6 @ v$ C( b7 O' G
* 函数名 : IIC_Start
& k& g. e, }. A& ?/ s7 b+ E" e
* 函数功能 : 产生IIC起始信号
5 P0 Z+ p( l: o3 d8 [, |
* 输入 : 无
8 n2 |) j1 p+ T3 k$ E& L4 c
* 输出 : 无! I! c; E: l) X
*******************************************************************************/2 f5 R0 R% Y# ?/ c2 {2 S, r7 `' p
void IIC_Start(void)
1 ?1 J8 p1 A- W- v
{
; T0 m2 K+ @7 H h
SDA_OUT(); //sda线输出
9 m) I( N8 z, i3 W
IIC_SDA=1;
1 E& I* e5 p" L m
IIC_SCL=1;
2 Y0 U V% J5 S# i; v% ]% ^2 h
delay_us(5);
# K3 t5 L5 Z1 E$ {+ h, \
IIC_SDA=0;//START:when CLK is high,DATA change form high to low
- g7 r( ~5 a" a$ D/ d% |3 z5 G
delay_us(6);
/ ]8 Y7 r% C: f1 i
IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
' Z/ d# S) `% `
} # C- P9 N; t2 E2 V* e' E) y
, J% ^1 P( T, g- e, W
/******************************************************************************** b" e7 N% k% d, \5 i' {% H# q! ~' t4 t
* 函数名 : IIC_Stop3 S+ K) G- K" |' D( r' P
* 函数功能 : 产生IIC停止信号 ' z! y- }# t0 X4 I- R
* 输入 : 无
) l0 n6 o8 @, i: ]& W
* 输出 : 无5 k( \5 ~" O( q8 w
*******************************************************************************/; A" p% i5 u2 \: K9 R" k
void IIC_Stop(void)
0 _+ [6 |3 Z! I/ K; C+ N1 M
{
! K' D% O% K F8 r( s
SDA_OUT();//sda线输出) @: h) G: X2 d# b
IIC_SCL=0;1 Q# s$ c' X8 ~ C6 N
IIC_SDA=0;//STOP:when CLK is high DATA change form low to high' }7 A! h2 K' g; ~9 O7 O0 ? @
IIC_SCL=1;
5 B. K: x4 }5 }% ~
delay_us(6); * o1 S$ `/ F" g5 t1 ?
IIC_SDA=1;//发送I2C总线结束信号2 K3 i( r. E q- T& F8 e0 N
delay_us(6);
) T4 O6 v! G% e: `7 Z
}
' G. l0 b& {. [6 k: L4 D
7 n' f( K( `% o( V
/*******************************************************************************
0 A" i Q1 r: f' B5 g
* 函数名 : IIC_Wait_Ack2 k/ p' W& J9 @8 R
* 函数功能 : 等待应答信号到来
; D, G0 f7 i. x4 I
* 输入 : 无 D" x! B+ Q3 W, f
* 输出 : 1，接收应答失败
c3 n8 Q* I3 S5 I. E
0，接收应答成功
7 p2 }. T, a% ^! y' E3 Q
*******************************************************************************/
9 b6 V+ ^& Y f0 p" T8 W
u8 IIC_Wait_Ack(void)
2 [7 U5 X5 X) F" ?% E# e
{8 o5 {1 Q6 }$ O7 x u. \! m( x9 f
u8 tempTime=0;( Y9 K$ i2 S" m5 H4 l2 e
SDA_IN(); //SDA设置为输入
2 Q3 u$ c `, s
IIC_SDA=1;7 a+ W: b/ H8 j
delay_us(1); X! r4 P: R: y9 p) U: Y
IIC_SCL=1;
6 `) g4 _( x2 S; O' K! i! R9 `
delay_us(1);
& Q9 Q: p4 G! ]$ f3 @7 v& y& Y' G
while(READ_SDA)" N) r8 L0 l# x9 n5 K
{) v% R; z" W, T# k) j( l
tempTime++;8 a0 Y- B8 j3 v& y. _
if(tempTime>250), s; \0 ^2 R3 \; _
{
, B' N; M" z9 i: ~ ?! K& W
IIC_Stop();
! I/ m7 `# _5 J# j* V9 M/ v
return 1;6 F( h- ` ?0 k B
}
' B. P# o$ o: i' J; t2 l7 D6 C
}
$ A$ f! X# A1 b
IIC_SCL=0;//时钟输出0
' {, @; I* o! r6 w8 l# q2 g
return 0; . }) n" N* F: k* C, ?; A
}
; v# ]3 Q: B9 o q$ [
3 N; P' g4 i' }; N" q
/*******************************************************************************% c4 r) O- E, l! O9 i8 P, D/ A
* 函数名 : IIC_Ack( ~3 h o! h- H2 n& }
* 函数功能 : 产生ACK应答
" e% s0 B! X0 i7 L9 S
* 输入 : 无
* J& [6 {; |8 |- v3 K. P
* 输出 : 无
0 J+ f0 n* d% D2 W3 I( L
*******************************************************************************/% \6 H* I# N) L
void IIC_Ack(void)) h& x- Z% L1 y9 i- _- h8 ~
{
8 Z! R# N9 y! Z, P1 W) n3 O% G
IIC_SCL=0;
( [" T+ g. }( S
SDA_OUT();/ x$ n* }% Z4 O' b
IIC_SDA=0;6 F' ~0 x9 U0 @; W7 z9 P+ F0 g
delay_us(2);
5 j0 h; ~; Z& `; W; K+ F
IIC_SCL=1;
9 x0 o* g/ w1 H7 f% m
delay_us(5);( B+ V. J) R' |# @) H
IIC_SCL=0;
/ C- L( p" e a2 S
}
; F+ g0 C3 q9 K- Y
3 ]1 j) \, s8 H2 U: d" U
/*******************************************************************************
! k+ g9 r8 I: ^3 M3 A
* 函数名 : IIC_NAck
3 y( F, B9 Y9 s1 O$ p M
* 函数功能 : 产生NACK非应答
Y! K& o. h) u- [+ z
* 输入 : 无! K; O* b, L4 e+ t
* 输出 : 无
' {; g- i4 n7 K1 H; W* n
*******************************************************************************/ : b& m" i6 D* m8 V. N( Q
void IIC_NAck(void)
) D8 a* x5 S0 u3 }9 `% @ [# y; O
{
3 h1 _) T D- I. P
IIC_SCL=0;
* A- }8 ~% I1 U) Y& K
SDA_OUT();
2 M: U) X0 [7 d3 E1 o7 X
IIC_SDA=1;
3 y7 ~0 ^0 I, b# U
delay_us(2);8 l/ ~% B* T9 B D8 T9 ?
IIC_SCL=1;
0 l3 k- {9 y) s: F$ q7 t
delay_us(5);. P+ z& {6 j$ g o& e k# i& D
IIC_SCL=0;+ _, G/ b/ k! @4 J9 o9 M( k: Y
} 7 _, h8 w& m6 p
* r* q0 z; g. M: C4 j5 I* c
/*******************************************************************************
# s5 y; w% R2 f0 J9 F
* 函数名 : IIC_Send_Byte
. O$ x% ^, F% i, A4 p
* 函数功能 : IIC发送一个字节
5 b, {; t! J# v, N% r9 n
* 输入 : txd：发送一个字节
6 t! Z" c" O1 l- v
* 输出 : 无! r3 r0 {9 y8 U2 N8 h
*******************************************************************************/ 4 i. f/ l. T% b, q
void IIC_Send_Byte(u8 txd)
F: Y0 U Y s+ ]: g# ^
{
5 V/ D4 o% C/ A# ]: W2 I$ f5 G9 W
u8 t;
: B9 X [: O2 |* f
SDA_OUT(); $ F9 g) j) F. V8 W7 B* ?! _/ N
IIC_SCL=0;//拉低时钟开始数据传输0 }3 C0 ^" E- B
for(t=0;t<8;t++)
. V" e! L9 m- m+ `! c* n6 `
{ ; e2 |) ?( J0 q: a! b
if((txd&0x80)>0) //0x80 1000 0000; H9 I( V7 W7 v( C3 A/ ^
IIC_SDA=1;
% R7 |* ^1 {% m ?4 a# O
else
! r: g" s7 H7 b
IIC_SDA=0;$ r4 _& u& r9 w5 |+ f
txd<<=1; ' M) `) o d2 O1 v6 F q" I
delay_us(2); //对TEA5767这三个延时都是必须的# `/ ^3 |4 N/ y1 A( A! w: G
IIC_SCL=1;
! Y; u* N' H" k8 N7 @- @4 p
delay_us(2); 4 g4 T7 R- @ ?8 ~! f" |4 @* m) x8 _4 \
IIC_SCL=0;
! c d+ n( r. S) p
delay_us(2);
, r) T( k. D4 j1 D/ C
} 8 ^& B& z' {% i. k
} $ l* N( N" F& T. ?' E0 g9 w; E( G
0 \9 v9 \- o) f) {, v- M
/*******************************************************************************
, p1 z! G, Q4 B% ]+ m
* 函数名 : IIC_Read_Byte
; i7 J3 A7 _9 q- P
* 函数功能 : IIC读一个字节 6 r3 k5 s% u, J$ ?/ e
* 输入 : ack=1时，发送ACK，ack=0，发送nACK " u6 Y p4 ?5 @, O$ E2 w7 k2 K
* 输出 : 应答或非应答6 f7 Y& n$ F; Y: \6 t1 L0 }
*******************************************************************************/
( ^5 g2 K6 ~. a C# ^
u8 IIC_Read_Byte(u8 ack)2 O# r+ O; t4 m
{& c4 s+ y- i; F8 q" D
u8 i,receive=0;9 s9 R2 X5 h6 ?& e, ?* ~% I3 R" A& L
SDA_IN();//SDA设置为输入 n' t$ ?. c O! j+ k; q. @
for(i=0;i<8;i++ )
: B0 l( x5 U2 Z- y" S
{
8 X( e; c. m9 w% Z5 @
IIC_SCL=0;
" P/ T( `" i* m, r9 C% r$ L
delay_us(2);
+ C D& M* W2 X: J
IIC_SCL=1;8 q2 p9 B. U: P0 A2 l- h
receive<<=1;2 S/ S* k4 ~# |4 e2 a3 v+ A u4 N
if(READ_SDA)receive++; 6 M0 b# u8 e9 _+ Z- G9 x
delay_us(1); ; ^4 H5 r- ]) S2 o4 {- k; q# x8 O
} ) W: k& Z r+ G8 d1 B# y
if (!ack)2 E5 K2 O6 l" Z: d( g5 o
IIC_NAck();//发送nACK
b; @' w# j/ Y8 {! g* F" K; m
else! @( b1 ]" @- N& r4 ~
IIC_Ack(); //发送ACK 7 |! T; e9 j. @& W
return receive;* u: c7 V) R6 S5 W; O R
}
$ `) K1 O a1 d
/*******************************************************************************
1 U8 k- k7 ^0 Z" d5 M
* 函数名 : AT24CXX_Init \$ G* ~8 l8 }$ b2 f1 l% A) u
* 函数功能 : AT24CXX初始化
I& R: \' B. P; a
* 输入 : 无 R. }/ J& J3 K5 e
* 输出 : 无
+ Y6 X# y# Q( U, S) e D
*******************************************************************************/
* V' e! j+ @$ d( l
void AT24CXX_Init(void)
; |3 i: @% F7 i6 N
{
$ ]. A) M1 l" a& n( J
IIC_Init();//IIC初始化
8 f# m5 ~+ m+ M. B* Z, ^) T, r4 e
}% X0 j3 h1 x/ G" H8 Y
( H9 i8 C" K& n8 \7 e' Z( k6 A
/*******************************************************************************$ v6 w5 u6 A7 B6 G
* 函数名 : AT24CXX_ReadOneByte3 A& {9 T6 F/ w0 f" `5 B+ G
* 函数功能 : 在AT24CXX指定地址读出一个数据
+ {; m7 H" C% |& e4 K3 F
* 输入 : ReadAddr:开始读数的地址 - z6 v% y l- o5 v% c& E
* 输出 : 读到的数据
' j% ?, f3 ?/ R) m5 D
*******************************************************************************/0 F2 r% s; e: J+ O
u8 AT24CXX_ReadOneByte(u16 ReadAddr)
! E% \' n5 n" U5 K$ z
{
4 [$ B" E6 L) \
u8 temp=0; % E9 B4 x j0 X( z! V
IIC_Start(); ! O) y" b6 M) U8 g/ L
if(EE_TYPE>AT24C16)
( b0 {. h0 q. o; u9 O
{$ b$ i. N5 h5 a. B. C1 b" K
IIC_Send_Byte(0XA0); //发送写命令
3 t4 {4 F' x, b; A
IIC_Wait_Ack();0 d, H/ _, x2 f) S1 X
IIC_Send_Byte(ReadAddr>>8);//发送高地址
0 M1 [" M, |: ~* q2 ?' g
}" |7 @" B* z% x- `
else 9 Y% s- T/ A9 B
{1 ^# @$ S$ H& b# h: d
IIC_Send_Byte(0XA0+((ReadAddr/256)<<1)); //发送器件地址0XA0,写数据
6 J4 h# I$ \1 M" \* I' R' @
}
1 D6 x0 T0 B* m- t1 c
IIC_Wait_Ack(); 9 d x2 }. V) l. C f; w8 Y
IIC_Send_Byte(ReadAddr%256); //发送低地址
( m( \! ^, V( E1 R
IIC_Wait_Ack(); # u& M6 d& \! q) i5 j& j
IIC_Start();
! r2 _; o8 q0 ^: t& {/ P) q
IIC_Send_Byte(0XA1); //进入接收模式 8 i4 O8 D0 U8 O0 O
IIC_Wait_Ack();
" F$ Q( O* R* d0 X2 n1 F1 P; Z
temp=IIC_Read_Byte(0); # w, T% L; i& V$ H
IIC_Stop();//产生一个停止条件
9 o# w3 \. G- E. N
return temp;0 c: o5 R( @5 e/ N
}
* l# R( m! M; @$ i, r2 W
. @" A# Q- W+ ~" B
/******************************************************************************** u. @$ {. U# S: Q5 A f6 N1 B* K
* 函数名 : AT24CXX_WriteOneByte: R: L& l& E' F# Q q
* 函数功能 : 在AT24CXX指定地址写入一个数据4 L. l( H; S* D9 Z- `& A9 T
* 输入 : WriteAddr :写入数据的目的地址 ) K8 f+ ]* Z& |* |
DataToWrite:要写入的数据
8 q: p; t# G" L' G ]! g) q
* 输出 : 无
$ o7 u4 y% \8 t0 i5 m0 j) @* j
*******************************************************************************/( A2 I- n( n6 F
void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite): R) y% J2 X) ^( ]
{ " b7 \3 d" E5 n" O
IIC_Start(); $ F5 j. ^! E2 A' j* A
if(EE_TYPE>AT24C16)
$ l4 A/ v1 b* C( {
{
# y) V; b7 P7 P: `& v
IIC_Send_Byte(0XA0); //发送写命令
7 f) s$ P: d6 U7 O I
IIC_Wait_Ack();( v0 I: n. E \
IIC_Send_Byte(WriteAddr>>8);//发送高地址
* j$ O4 e4 J0 G3 P5 C7 l
}
Q( [0 O. R2 H5 b/ R
else
# t1 l' [5 N+ A5 E7 R
{
' F4 E8 F' p% w% Z' @8 H
IIC_Send_Byte(0XA0+((WriteAddr/256)<<1)); //发送器件地址0XA0,写数据
( M' }) U4 h# h% V( `4 [! I0 V8 h- _
}
8 _7 k% Q+ s, ?/ r% ~; m( n
IIC_Wait_Ack(); + u) S9 M6 C g$ Y' ]
IIC_Send_Byte(WriteAddr%256); //发送低地址
% G; t6 C' A% p$ f1 M8 @9 k) ?
IIC_Wait_Ack(); ! E8 [! \/ L8 Y8 N) D
IIC_Send_Byte(DataToWrite); //发送字节
7 e+ Y$ {0 r& a8 {
IIC_Wait_Ack();
: p/ ~. E0 F" T: i: v) K, L
IIC_Stop();//产生一个停止条件
- G/ v1 I7 Q" W' K
delay_ms(10); " ^; h8 w- L+ q. @" \7 n3 R
}& r& k9 @- D( }9 r
% P- N: X+ L: A- ~1 `
/*******************************************************************************! q* N" q8 R: [) }; w; Y4 `$ f
* 函数名 : AT24CXX_WriteLenByte3 P6 b' P5 z0 N( u' Y. v
* 函数功能 : 在AT24CXX里面的指定地址开始写入长度为Len的数据9 |4 _6 L0 O$ P: N4 X! j' B( H
用于写入16bit或者32bit的数据
6 H$ @( N5 u4 N, Q
* 输入 : WriteAddr :写入数据的目的地址
1 ^) }/ |% v* x+ p# s8 E8 e
DataToWrite:要写入的数据2 V8 L/ c4 g5 K& R& Q9 m# J
Len :要写入数据的长度2,4
, L1 H: Y( n; [" z w
* 输出 : 无3 t* D# B* |! C) O9 l
*******************************************************************************/# d2 W+ b& c/ p( ~& {/ v5 k
void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len)
D7 o, x6 ^9 v- ]
{
z0 }' W( V# l( O) v
u8 t;
: c$ w; E9 [- x3 S- V1 x4 |* z9 G a
for(t=0;t<Len;t++). a! S* U: ~+ f
{
( h. d3 x; }# m0 X$ c5 t
AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);, Z% E6 H: j6 M6 K4 U b: z' a
} ( j8 E" @& T1 W/ p
}
8 h# m! M3 _! v, D r* ]
( a' ?7 P- K5 T% @( t3 X. n5 \- ~
/*******************************************************************************
( Q& h7 ]% R5 I( N
* 函数名 : AT24CXX_ReadLenByte/ H' K9 G& R. v/ w. U, _) {5 f
* 函数功能 : 在AT24CXX里面的指定地址开始读出长度为Len的数据; [) T) e3 {8 m2 ~( n2 \
用于读出16bit或者32bit的数据
) y4 I5 f' c0 w- m n8 N
* 输入 : ReadAddr :开始读出的地址
* j) \6 M& [3 ~% _' D3 n8 w6 @
Len :要读出数据的长度2,47 ?7 s, ]& a2 T
* 输出 : 读取的数据
9 I! \1 H9 K8 ^
*******************************************************************************/
7 n$ I3 R' e$ a2 M
u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len)
, G& h) _5 T/ R0 n: R2 L0 u; _
{
- b6 P/ G" O% F- y
u8 t;7 \8 \3 q% ^9 z4 w6 J, v% _
u32 temp=0;. a# l% w( c+ h" K$ h5 R* a
for(t=0;t<Len;t++)1 Q, u: l9 p( \3 j. D& ]/ @
{( s: `0 u" u# ]( t8 _
temp<<=8;# V" ]2 _! o5 z% E9 q8 }; ^* C
temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);
5 Y/ F0 n U; B. L8 g
}2 L) n( }. \8 q, e+ s; T
return temp; / i' G- z' f9 V( z
}* Z- E' p* _9 S! B! A' X" x
& K# S7 m! U7 z1 P" ]
/*******************************************************************************' i) x/ N% C$ E& N) @
* 函数名 : AT24CXX_Check
) c+ o: O1 ~$ {
* 函数功能 : 检查AT24CXX是否正常' c& p7 E" |% ?3 n: `
* 输入 : 无: }% D' Y9 m+ H* ?' s
* 输出 : 1:检测失败，0:检测成功
$ U y6 T7 [: w$ a$ A( j7 m
*******************************************************************************/
% Z1 ?- p' x B. T1 E
u8 AT24CXX_Check(void)! N# m1 c% k0 p9 a' s& H
{% q! E7 I& @: f7 c9 d, U+ I
u8 temp;
. J" r2 f" C/ q3 O" h
temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX
# F% S" r) e* I/ N
if(temp==0x36)return 0; ) K1 N! [( }) b$ H5 `
else//排除第一次初始化的情况& |) D, ]3 h2 @+ u* b3 Q1 O% f
{$ ] B o* \: ]) |
AT24CXX_WriteOneByte(255,0X36);/ Q6 `8 ~6 p* C
temp=AT24CXX_ReadOneByte(255); ; V4 i$ e J- b- f Z( O
if(temp==0X36)return 0;
, V+ H9 [& A" G4 Y' F, p
}
+ N9 z% n: a/ [; _7 a2 g( t
return 1; 2 w( u/ L% M! a' x
}
& ?3 b# V7 u- u8 g6 S4 J
2 f7 n7 p' Y9 z+ I! ?
/*******************************************************************************0 @8 K5 u: m5 }1 |# y7 {
* 函数名 : AT24CXX_Read
+ R4 ]: H, D X' n* [) {
* 函数功能 : 在AT24CXX里面的指定地址开始读出指定个数的数据; j: y7 M" f. S
* 输入 : ReadAddr :开始读出的地址对24c02为0~255
) q& n$ R8 L. x' Q, a; X- x$ Y& W& t
pBuffer :数据数组首地址5 |- Q/ N5 ]: t2 U) |
NumToRead:要读出数据的个数
4 I# s" k m; H5 t* H
* 输出 : 无
+ ], J4 X0 A8 Y
*******************************************************************************/
) u$ N0 A' K, M; f
void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)1 J9 T/ h/ b& k1 F
{/ T3 n1 N6 z( o( M7 S q) K
while(NumToRead)8 d0 c, E+ C( o. B- ^6 q/ |
{
+ L. e- L" Z8 `, G8 g1 E$ P! x
*pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
% [0 J T+ B4 Z+ A
NumToRead--;3 C& x% e0 C4 |6 G3 h8 f4 m
}
; Q) v! Q3 v( d
}
$ n+ Q+ g" Q7 X7 {
! V! j' Q) R5 t7 j0 `+ S Y) C
/******************************************************************************** q! L3 R) I* E# d( c0 V
* 函数名 : AT24CXX_Write
* ~! L8 [% c3 ^# U! y- z
* 函数功能 : 在AT24CXX里面的指定地址开始写入指定个数的数据. F6 N) V. ^1 U
* 输入 : WriteAddr :开始写入的地址对24c02为0~255
1 o! L! R- a5 k$ O$ T% ?
pBuffer :数据数组首地址1 ^5 C% j, z4 |$ a; Y9 Q% J+ y
NumToRead:要读出数据的个数
( y$ _! h8 Z( g4 E5 [' M
* 输出 : 无
: O" f, ]. a1 k4 J: c
*******************************************************************************/
, X q) W6 z5 q, _6 N- {, c7 u
void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite); N' c& _& |% F. B3 Q) t& g' y
{% y+ o9 h# U+ k
while(NumToWrite--)! {7 e2 `+ |8 C/ @, P
{
# W/ c3 f, Q' R* j; S
AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
+ I5 x/ Q' ^* }) t
WriteAddr++;
8 }; o7 q& F- P
pBuffer++;+ c8 A. _: }: X5 s% J
}
6 c, f7 } b9 s. ]0 G; f: ]
}. z+ G2 v4 F. ?& _" Y) p
.h文件如下5 _/ o5 r5 Z# {
0 U) W! Z; E: Y/ ?
// 核心板使用的是24c02，所以定义EE_TYPE为AT24C02
* [# Q9 P* e2 Y0 _+ [0 o; ^
// 可修改成AT24CXX系列中的任意一个
" }! u d4 z' i) T
#define EE_TYPE AT24C027 a6 i) `9 z( T) ?
- d; W2 D( _) w. r2 k" b. s0 Q
// IIC函数
1 F- V$ d4 P: t. {8 L
void IIC_Init(void); // 初始化IIC的IO口 E6 E- O6 n& \# \) a
void IIC_Start(void); // 发送IIC开始信号
5 U. O2 N& R; \# ]' v2 P7 `
void IIC_Stop(void); // 发送IIC停止信号
3 e+ j9 Z1 v, l7 [% K( V
void IIC_Send_Byte(u8 txd); // IIC发送一个字节& Z6 v: K+ z$ j8 f O1 x
u8 IIC_Read_Byte(u8 ack); // IIC读取一个字节1 e) w5 z! }8 ~+ D0 N$ K0 D9 h
u8 IIC_Wait_Ack(void); // IIC等待ACK信号
: L1 w5 B) r" c7 l8 ~; L8 _
void IIC_Ack(void); // IIC发送ACK信号
1 }8 A5 I: {8 S4 J+ r' O- ]! A
void IIC_NAck(void); // IIC不发送ACK信号. c4 b6 s4 `- ^+ B7 `
" a. ]1 o0 b N+ K, f, ~* P. b& c
u8 AT24CXX_ReadOneByte(u16 ReadAddr); //指定地址读取一个字节" o- Y- P! E+ `+ [+ I) l8 S
void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite); // 指定地址写入一个字节9 x9 i2 y9 D' e4 w/ Q1 C7 c
void AT24CXX_WriteLenByte(u16 WriteAddr,u32 DataToWrite,u8 Len); // 指定地址开始写入指定长度的数据
* f8 ?3 r. J Z) I
u32 AT24CXX_ReadLenByte(u16 ReadAddr,u8 Len); // 指定地址开始读取指定长度数据) r0 Q0 [# }7 z r2 W8 @
void AT24CXX_Write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite); // 从指定地址开始写入指定长度的数据
4 U6 M5 I3 n2 F5 D
void AT24CXX_Read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead); // 从指定地址开始读出指定长度的数据, u9 q' o! C4 V0 N- \
8 B$ \" d2 i; m" i% R" Y0 O7 q
u8 AT24CXX_Check(void); // 检查器件9 {- Q. @3 Q' K/ x3 B+ F
void AT24CXX_Init(void); // 初始化IIC