一、源代码

1. void eeprom_init()
   
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStructure;
   ; n, C7 h, ]3 }+ D3 C
4.          SPI_InitTypeDef  SPI_InitStructure;
   
5.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
   
6. 
   8 L+ v  v. L' f
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12;  // PB12 推挽
   ( A+ R7 f/ F; f/ S1 W  E
8.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
   
9.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
10.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    7 x# [, c- K& _1 [
11.         GPIO_SetBits(GPIOB,GPIO_Pin_11|GPIO_Pin_12);
    
12. 
    - a' K  ?9 j/ x' P8 r- D  q
13. 
    
14. 
    
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
    
16.         RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能         
    & ^- E! C1 m0 _
17. 
    ( |; e  E" H8 m* u; m
18.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    $ g4 [# G, L6 d9 ?5 p  u
19.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出
    $ k5 w  `/ @7 C# i- a( N
20.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
    7 c$ N; o- f# o
22. 
    
23.          GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉
      ^0 I$ R# D+ `$ i5 X5 d
24. 
    9 i  o3 s4 R; [
25.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
26.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    
27.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
28.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    . E8 |8 t9 y& W0 Q% f$ ^
29.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
30.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    % |# L5 `1 D9 t$ J+ q
31.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    % d. K3 @2 ^' m( L" ]( d
32.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
33.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
      [1 M/ T$ @3 F4 f! }" f
34.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    . q8 ]" W7 O0 U) C, {
35. 
    & G9 Z# P) H( U# _5 Q' k
36.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    . K9 F- u3 f% ^1 i. ^* G
37.         
    
38.         eeprom_read_write_byte(0xff);//启动传输               
    ; A1 `+ \; Q% u
39. }
    3 A; R, _: m9 H% T
40. //SPI 速度设置函数
    
41. //SpeedSet:
    
42. //SPI_BaudRatePrescaler_2   2分频   
    1 v0 M. x/ T2 w, x3 T% g
43. //SPI_BaudRatePrescaler_8   8分频   
    
44. //SPI_BaudRatePrescaler_16  16分频  
    * E7 A  c) a0 C/ O7 a1 G# r
45. //SPI_BaudRatePrescaler_256 256分频
    
46. 
    % H/ E/ T' J$ r: U* T
47. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    + y7 q9 p5 y. c9 H2 U
48. {
    + Q5 e  v% |: |9 o. y. Z6 \' _  V
49.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    5 u. \  f/ n. I
50.         SPI2->CR1&=0XFFC7;
    " l+ J. R# T' k6 |2 M
51.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI2速度
      t% ^, P- L9 V" q. e
52.         SPI_Cmd(SPI2,ENABLE);
    $ X- Q* y: l# v
53. 
    
54. }

复制代码

1. //SPIx 读写一个字节
   
2. //TxData:要写入的字节
   
3. //返回值:读取到的字节
   
4. u8 eeprom_read_write_byte(u8 TxData)
   2 |* Z" y$ @; U8 E7 b4 v( s
5. {               
   $ `, y7 l4 T  |+ y, s
6.         u8 retry=0;                                         
   
7.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
   
8.                 {
   7 r9 U1 c* T4 l- V( R
9.                 retry++;
   
10.                 if(retry>200)return 0;
    ' T) U; D! c2 i4 m
11.                 }                          
    
12.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
    4 W7 G; a- x$ T' T) O
13.         retry=0;
    4 {5 }9 c, v: |) \7 V9 X
14. 
    
15.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    9 N& a2 k9 b* f* h& i
16.                 {
    
17.                 retry++;
    8 P4 L7 \  t. C. D& l
18.                 if(retry>200)return 0;
    . A7 |1 c5 I$ ~3 @, h. o
19.                 }                                                              
    
20.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
    
21. }

复制代码

1. //==============================================================================
   ) e9 q7 I* D1 {" R) U) q
2. // 描述: 在AT25读状态寄存器
   ; p# h. W: ]9 `9 T; s
3. // 输入: 无
   
4. // 返回: unsigned char dat 状态寄存器数据
   
5. //==============================================================================
   1 L+ @% W9 l& x& S
6. 
   
7. 
   
8. u8 eeprom_read_sr(void)
   - ^6 i' v# {  z5 \+ K# j* L3 {
9. {
   : }( K0 h- {0 U/ A/ l
10.         u8 dat;
    
11.         eeprom_cs=0;
    
12.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
    
13.         dat = eeprom_read_write_byte(0xff);       //  读回数据
    
14.         eeprom_cs=1;
    . h# z/ Q( b5 l" v4 u* a2 R
15.         return  dat;
    
16. }
    
17. 
    
18. //==============================================================================
    
19. // 描述: 向AT25写入一个数据
    ) |3 s- H$ S" }" l) W
20. // 输入: unsigned char Dat 字符数据
    , p0 H/ T1 }8 ~
21. //       unsigned int addr 写入的地址
    . Z' _3 |; c5 t: s( F3 o5 H, u0 n, X
22. // 返回: 无
    + |# W* @! ?. q- \6 D+ C' Y
23. //==============================================================================
    
24. void eeprom_write_byte(u16 addr,u8 Dat)
    
25. {
    
26.         unsigned char Add;
    , |2 g8 f6 b: S. F% o* c" F
27.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
    
28.         
    8 o1 e1 B2 t, Z2 m- d% z
29.         eeprom_cs=0;
    
30.         eeprom_read_write_byte(WREN);                           // 写使能锁存
    * w  |. u! |% ?# G
31.         eeprom_cs=1;
    
32.         
    
33.         eeprom_cs=0;                                  // 芯片使能
    ( e& Q0 N1 i) e" O
34.         // 写入写操作指令
    
35.         if(addr>0x00ff)
    
36.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
    - D6 v* [5 b4 U3 l
37.         else
    
38.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
    % ?8 f5 t: [& L* r- f& S7 e3 T7 t8 e
39. 
    $ d" _+ g. y8 w$ Z& h2 O8 a
40.         // 写入地址
    
41.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
    
42.         eeprom_read_write_byte(Add);
    
43. 
    
44.         // 写入数据
    
45.         eeprom_read_write_byte(Dat);
    
46.         eeprom_cs=1;                                // 芯片关闭   
    4 Y$ E# D( ]! A. H# K& b- z2 n- o
47. }
    
48. //==============================================================================
    
49. // 描述: 在AT25读一个字节操作
    
50. // 输入: 无
    
51. // 返回: unsigned char dat 读出一个字符数据
    
52. //==============================================================================
    ! [/ a3 i- M. H9 A
53. u8 eeprom_read_byte(u16 addr)
    ) l  @) z" i7 I- n2 w
54. {
    
55.         u8 dat,add;
    % W5 G' _6 b% E# o
56.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
    # q, X  ?9 ^0 t9 n" {9 B0 f
57.         eeprom_cs=0;
    5 i3 \( b$ g+ l) j
58.         // 写入写操作指令
    
59.         if(addr>0x00ff)
    
60.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
    
61.         else
    5 Y7 ^7 a7 i" e, M* S
62.                 eeprom_read_write_byte(READ);                  // 地址小于255
    
63. 
    
64.         // 写入地址
    ' r' y5 \" \% K  R3 e0 u4 }- a
65.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
    4 b: i; J. X! B8 i
66.         eeprom_read_write_byte(add);
    
67. 
    
68.         // 读出一个数据
    ( H& X) K8 Y9 b: R" a
69.         dat=eeprom_read_write_byte(0xff);
    ; g! S- Z; U) v" A8 h9 M
70.         eeprom_cs=1;
    
71.         return dat;
    
72. }
    
73. //==============================================================================
      K1 m& Z) S1 O# c* U' x& e
74. // 描述: 向AT25连续写入数据
    " T* |! p; Y% p/ _. Y) o6 o
75. // 输入: unsigned char *PC 写入数据指针
    
76. //       unsigned int count 写入数量计数  
    % I# ~! ^5 h3 j: b8 j! L; N2 W
77. //       unsigned int SatAddr 写入起始地址
    , w) h, h. I9 e# t
78. // 返回: 无
    
79. //==============================================================================
    
80. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
    
81. {
    
82.         u8 Add;
    
83.         u16 i;
    
84.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
    
85. 
    
86.         eeprom_cs=0;
    
87.         eeprom_read_write_byte(WREN);                           // 写使能锁存
    ' L+ l5 e) d! }/ M
88.         eeprom_cs=1;
    + u9 y, ?( C$ D: _: k3 b
89.         eeprom_cs=0;
    & A0 y. q( v. P2 Z& m/ G. h
90.         // 写入写操作指令
    
91.         if(startAddr>0x00ff)
    ; g$ I/ n+ y& S$ o; V+ v! ?! ~1 g
92.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
      ]% ^) f2 O0 J4 T( }) z
93.         else
    
94.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
    
95. 
    
96.         // 写入地址
    
97.         Add = (unsigned char)(startAddr & 0xff);             // 将地址换成8位
    / ?. J7 ]4 K4 I8 S3 L) Z4 w
98.         eeprom_read_write_byte(Add);
      |8 x8 ]& L9 W' }
99. 
    - [$ D; D5 x1 D) J: B0 ?9 H$ e
100.         for(i=0;i<count;i++)// 写入数据
     
101.         {
     0 e+ o  r5 G# _2 f. m& X( I! o
102.                 eeprom_read_write_byte(*buf++);
     
103.         }
     8 R" \2 V" o# h4 h  ?# m6 {
104.         eeprom_cs=1;                                 // 芯片关闭   
     - ~9 {- N; J* I
105. }
     
106. //==============================================================================
     # ]( g. @+ w1 E& u5 J9 b- E
107. // 描述: 在AT25连续读数据
     
108. // 输入: unsigned char *PC 读出数据指针
     
109. //       unsigned int count 读出数量计数  
     & q$ W) P+ H& ^0 K5 d
110. //       unsigned int SatAddr 读出起始地址
     8 M; J/ @8 R6 m4 d6 p# h: B
111. // 返回: 无
     
112. //==============================================================================
     & |& O8 b7 L9 @$ z4 e
113. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     / U* h$ y3 N  T/ w( ^
114. {
     
115.         unsigned char Add;
     
116.         unsigned int i;
     - b3 A; `/ k! V* ~: Y* i: Y
117.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
118.         eeprom_cs=0;
     0 d6 e: l) M' N, M* L
119.         // 写入写操作指令
     " y. q( y8 x; k$ i
120.         if(startAddr>0x00ff)
     ! v2 q0 N8 ?/ v1 d' M: N
121.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     4 A( I% B9 i! h6 k7 ~9 L
122.         else
     
123.                 eeprom_read_write_byte(READ);                  // 地址小于255
     1 g, G& S4 U- V" B( E; v# f' w
124. 
     " n* [4 Y1 Z& n+ [( y6 ]. Y
125.         // 写入地址
     
126.         Add = (unsigned char)(startAddr & 0xff);             // 将地址换成8位
     % e* |; |1 T8 H+ E
127.         eeprom_read_write_byte(Add);
     ; j2 o" a  H' N- l2 o1 s7 e3 _- e. Q* V- g
128. 
     ( o( e. h2 u7 C4 _% a5 c) L
129.         // 读出n个数据
     2 n& u2 d# h" ~& N  Y
130.         for(i=0;i<count;i++)
     : J: m- |9 |3 k$ S
131.         {
     " f5 f5 y3 |9 C: R
132.                 *buf++ = eeprom_read_write_byte(0xff);
     
133.         }
     
134.         eeprom_cs=1;
     ) ^8 W: k) |* p: P
135. }

复制代码

二、测试

  @0 _% I  \2 o0 g9 q0 z& M

1. int main(void)
   2 }; _, W. q. W" `' l( S
2. {        
   
3.         u8 buf[5]={0x01,0x02,0x03,0x04,0x05},i;
   
4.         uart_init(115200);
   2 z* Z/ ~1 {8 l$ Q
5.         delay_init();        
   9 z" ^) B9 l# [2 T; g5 Y) }
6.         program_led_init();        
   3 Y' r, S3 d  p% f/ q
7.         
   
8.         eeprom_wp=1;
   , K- ~- }. d, U5 S: M) w
9.         eeprom_init();
   - f) \9 b9 O$ R9 u7 G% R. @
10.         eeprom_write_buf(0x0000,buf,sizeof(buf));
    4 E  d9 S$ d) T: e# `, G4 h6 f
11. //        eeprom_write_byte(0x0000,0x08);
    : R8 @; p4 f( t7 ]+ R& g' G
12.         memset(buf,0x00,sizeof(buf));
    
13.         eeprom_wp=0;
    
14.         while(1)
    0 n# g# [4 i6 r, I8 t
15.         {        
    4 U& k" `$ P* \5 q
16.                
    9 v0 f; u% z/ R
17.                 eeprom_read_buf(0x0000,buf,sizeof(buf));
    # Z6 N' ]" Z. y- s0 z
18.         //        buf[0]=eeprom_read_byte(0x0001);
    
19.                 for(i=0;i<sizeof(buf);i++)
    # z) j: {7 z5 J) O. s% S8 C
20.                         printf("0x%02x ",buf<i>);
    
21.                 printf("\r\n");
    , l1 O  Y  a! B/ F
22.                 memset(buf,0x00,sizeof(buf));
    
23.                
    
24.                 program_led_data(0x10,0x10,0x10);
    ; x2 D# x; X- b3 n/ W
25.                 delay_ms(500);
    2 h3 p- M$ a" }; d' u" W
26. 
    , R7 Y5 G# ~5 g& ^3 f9 s/ Z- G
27.                 program_led_data(0x00,0x00,0x00);
    % }8 W* C* `5 e8 a
28.                 delay_ms(500);        
    8 x5 [' S. R( d. o3 O
29.                
    % u* Z/ {' h0 d8 @& c" j
30.                
    5 W9 Y/ g% P9 |2 p( i3 w
31.         }
    9 d) P5 u3 p: Q: B6 J) o, N
32. }
    
33. 
    ' F8 k/ U( A2 b- I2 p! M& f) v
34. 
    4 `8 s9 D& \( W, g6 H- u' D
35. </i>

复制代码

* K( Z, w% ~/ q- K( f