一、源代码
  y2 X* k, U8 a9 c& d" L
2 g/ I: u* i; R* a

1. void eeprom_init()
   
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4.          SPI_InitTypeDef  SPI_InitStructure;
   
5.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
   ) h0 @- }* ]" m6 O( k/ z9 o
6. 
   , n9 W( a& _( n. U/ N; E. S
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12;  // PB12 推挽
   
8.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
   ) c! j% \" e8 z' ?" C
9.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
10.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    9 `. c3 H0 Z8 |; T# u1 M: q5 l
11.         GPIO_SetBits(GPIOB,GPIO_Pin_11|GPIO_Pin_12);
    
12. 
    / r* u% q6 Z* L% }# P
13. 
    
14. 
    
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
    
16.         RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能         
    
17. 
    8 i4 z: f: V2 B8 \. e$ G+ J
18.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    4 X7 T2 q) ?( ]/ f& C
19.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出
    ! T8 L# T- ]* u7 Z
20.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
    $ l$ E) l; c0 B
22. 
    + r* b0 E- S5 c- J1 n
23.          GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉
    , Q+ S+ g& S' `/ q
24. 
    ' [( x( i1 V& y3 Q5 H1 C
25.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    5 Z2 V$ m5 g3 b/ Q+ v% D
26.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    , @% z% Z+ f6 ^4 l! f
27.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    1 @. ?; h' M8 T$ F7 W. y: a) s
28.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    # A" b8 e" |+ @, \
29.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    8 d% Q- ]. l3 Y# b1 G. n" X. O
30.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    / _. ~3 P# E* O- {2 p
31.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    8 @; m5 b9 X. `5 C. X
32.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
33.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    3 F0 r5 u* `- w, m9 U9 L
34.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    3 |- E( Y: V0 f3 {% [
35. 
    ' b8 w; g5 B/ \3 S9 v# T
36.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    
37.         
    % C% K9 @, N, G: s4 S3 G% T( F1 n
38.         eeprom_read_write_byte(0xff);//启动传输               
    + {4 ~+ b5 G+ o7 E/ m
39. }
    
40. //SPI 速度设置函数
    
41. //SpeedSet:
      T7 Y/ G  p5 a5 D# Y' k, ]5 D1 {
42. //SPI_BaudRatePrescaler_2   2分频   
    3 {9 y, X; c2 |9 p( I- b" h  ]8 f0 {
43. //SPI_BaudRatePrescaler_8   8分频   
    
44. //SPI_BaudRatePrescaler_16  16分频  
    + t: c3 j9 s: {
45. //SPI_BaudRatePrescaler_256 256分频
    
46. 
    * z4 t4 _6 ]. U
47. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    / v8 K6 b' i# `4 f* z& _" k  Z# o
48. {
    0 ^) o6 u* T+ C/ U. O
49.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    & w2 o7 }2 ?# }3 Y% n
50.         SPI2->CR1&=0XFFC7;
    
51.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI2速度
    , Q3 \6 Q- _$ o1 |
52.         SPI_Cmd(SPI2,ENABLE);
    
53. 
    
54. }

复制代码

1. //SPIx 读写一个字节
   
2. //TxData:要写入的字节
   
3. //返回值:读取到的字节
   
4. u8 eeprom_read_write_byte(u8 TxData)
   6 u0 M4 b" S5 p% m: C
5. {               
   
6.         u8 retry=0;                                         
   2 ^) @* f9 ?$ K! S
7.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
   & \+ H3 C1 P$ D; F  d
8.                 {
   ) v  s8 E8 o! p, |
9.                 retry++;
   
10.                 if(retry>200)return 0;
    % x5 [+ v4 ]4 C
11.                 }                          
    ' U+ l9 u5 g% `; |. x" h
12.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
    
13.         retry=0;
    
14. 
    : F' o; y7 v2 a, M; a) J
15.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    
16.                 {
    
17.                 retry++;
    & G1 `# ?$ j' m5 I7 j/ e/ F
18.                 if(retry>200)return 0;
    
19.                 }                                                              
    % B3 p  s4 ^( {4 G. k, T
20.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
    # S- O- Q5 G6 p& s
21. }

复制代码

1. //==============================================================================
     r2 L& i  I; U. F+ b$ ]6 B
2. // 描述: 在AT25读状态寄存器
   
3. // 输入: 无
   
4. // 返回: unsigned char dat 状态寄存器数据
   
5. //==============================================================================
   
6. 
     K7 n6 u& Y! h! A) {
7. 
   5 e8 J1 M3 e: y5 n% M
8. u8 eeprom_read_sr(void)
   6 {# L: S. x. X- l) ]% \% \' P# v
9. {
   
10.         u8 dat;
    9 i9 F9 h: [2 C/ w2 D% l
11.         eeprom_cs=0;
    4 A) X2 g6 }( ?+ @) P( ]
12.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
    
13.         dat = eeprom_read_write_byte(0xff);       //  读回数据
    8 \' A. C% V+ Z3 h3 ~
14.         eeprom_cs=1;
    & i; a" y7 e- ?+ v' V
15.         return  dat;
    
16. }
      c, V7 m# e# t  L
17. 
    / k& e1 _, l! B& Z6 P& |
18. //==============================================================================
    
19. // 描述: 向AT25写入一个数据
    
20. // 输入: unsigned char Dat 字符数据
    - N5 J& H4 I5 `  I! X- j
21. //       unsigned int addr 写入的地址
    
22. // 返回: 无
    
23. //==============================================================================
    7 k# b7 ?3 [$ ^
24. void eeprom_write_byte(u16 addr,u8 Dat)
    + Z5 v8 t+ i; B3 O- d' T
25. {
    
26.         unsigned char Add;
    
27.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
    
28.         
    
29.         eeprom_cs=0;
    9 X# s. S$ Q% L3 P0 A: w) g; Z
30.         eeprom_read_write_byte(WREN);                           // 写使能锁存
    
31.         eeprom_cs=1;
    
32.         
    7 b6 \0 Y1 [! C* l: Q
33.         eeprom_cs=0;                                  // 芯片使能
    ( V" q/ Y# x' {! y) t
34.         // 写入写操作指令
    0 K6 V! v6 u+ G8 R4 b  {* i1 N4 t
35.         if(addr>0x00ff)
    
36.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
    1 M! @5 ]% e  E( J+ i$ [, Q
37.         else
    
38.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
    
39. 
    ! v: G: C2 ^7 @7 V
40.         // 写入地址
    
41.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
    " F: W5 P+ _( h+ x" k( L- |
42.         eeprom_read_write_byte(Add);
    6 ^1 t0 f: p8 x0 I" r
43. 
    
44.         // 写入数据
    1 b  j# f/ Q3 V
45.         eeprom_read_write_byte(Dat);
    
46.         eeprom_cs=1;                                // 芯片关闭   
    ' s, R6 X: G) Z4 r# Z
47. }
    
48. //==============================================================================
    
49. // 描述: 在AT25读一个字节操作
    / m* Y& }3 X6 R% ]
50. // 输入: 无
    ' ?# p4 ?6 A2 U* i) U
51. // 返回: unsigned char dat 读出一个字符数据
    
52. //==============================================================================
    
53. u8 eeprom_read_byte(u16 addr)
    & Z3 _! `  @3 V
54. {
    
55.         u8 dat,add;
    ! a6 n/ @5 z! G2 c
56.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
    
57.         eeprom_cs=0;
    ' z* @  a8 t4 t- m
58.         // 写入写操作指令
    3 N) q, D7 w$ Q/ e* M2 w
59.         if(addr>0x00ff)
    
60.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
    5 P( {2 x" [5 S1 A3 q
61.         else
    0 _9 f) A8 m) k. q: M, S
62.                 eeprom_read_write_byte(READ);                  // 地址小于255
    " I/ ^) B/ S3 a! N; E+ @) h. ?
63. 
      h: A# ?& i0 A
64.         // 写入地址
    : C2 j! u' [3 k! s
65.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
    : |" a4 y& `# |; R
66.         eeprom_read_write_byte(add);
    
67. 
    5 l6 ~; R- p; h5 j' [- g
68.         // 读出一个数据
    6 X" a8 h( l# H# Q5 I
69.         dat=eeprom_read_write_byte(0xff);
    / M  B6 s6 M+ R1 F7 V! _4 n; ?% C
70.         eeprom_cs=1;
    
71.         return dat;
    
72. }
    
73. //==============================================================================
    
74. // 描述: 向AT25连续写入数据
    + {) q) {# K4 ?- _' {
75. // 输入: unsigned char *PC 写入数据指针
    
76. //       unsigned int count 写入数量计数  
    
77. //       unsigned int SatAddr 写入起始地址
    
78. // 返回: 无
    # k- s) ?8 V) d+ u9 k
79. //==============================================================================
    
80. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
    1 `, ]. }. m. m
81. {
    
82.         u8 Add;
    $ x) \2 j, H8 @. V. G6 p; m
83.         u16 i;
    # [5 l! F4 C& `* c
84.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
    2 V" o0 W8 u1 K; U% [* ]
85. 
      V4 u5 Y+ P! X- ]  D; A) E: G
86.         eeprom_cs=0;
    ( z. i( F, W. Z* u9 E
87.         eeprom_read_write_byte(WREN);                           // 写使能锁存
    
88.         eeprom_cs=1;
    
89.         eeprom_cs=0;
    5 z6 S' ^1 G; R3 Z/ n+ l7 x3 n
90.         // 写入写操作指令
    
91.         if(startAddr>0x00ff)
    : ^& t6 E/ m  v. F% @6 o; N
92.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
    ' Y9 N6 \* G) y, t8 |. p/ m
93.         else
    
94.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
    . d6 f0 v; J) c4 l% J# G
95. 
    ; `2 N9 W3 Z% K
96.         // 写入地址
    7 A* v# q/ ?+ v8 f
97.         Add = (unsigned char)(startAddr & 0xff);             // 将地址换成8位
    
98.         eeprom_read_write_byte(Add);
    
99. 
    & o% ]3 s! c4 H4 h
100.         for(i=0;i<count;i++)// 写入数据
       l- j6 Y3 q/ ?+ E
101.         {
     : m0 L6 [; P$ o, I
102.                 eeprom_read_write_byte(*buf++);
     
103.         }
     9 v! \! g. M+ A% D( n
104.         eeprom_cs=1;                                 // 芯片关闭   
     
105. }
     
106. //==============================================================================
     $ M$ C, m. \) M4 z
107. // 描述: 在AT25连续读数据
     
108. // 输入: unsigned char *PC 读出数据指针
     
109. //       unsigned int count 读出数量计数  
     
110. //       unsigned int SatAddr 读出起始地址
     7 }3 V3 `; X7 m7 S8 h3 v7 |
111. // 返回: 无
     
112. //==============================================================================
     0 Q7 d, y& V+ a" m$ c; p- C
113. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     
114. {
     , Q' j1 T* }" ~+ F$ a
115.         unsigned char Add;
     
116.         unsigned int i;
     % k5 n* H1 D% [( f7 n/ |
117.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
118.         eeprom_cs=0;
     
119.         // 写入写操作指令
     ( _5 E8 Q+ C- c/ c$ @) S6 C
120.         if(startAddr>0x00ff)
     
121.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     
122.         else
     / F& l9 ]6 \6 o
123.                 eeprom_read_write_byte(READ);                  // 地址小于255
     ; j: X3 N- Z  o+ k4 N4 `
124. 
     + K- G# `* ?: }2 a' @
125.         // 写入地址
     ( ^% D4 O( L1 K2 L
126.         Add = (unsigned char)(startAddr & 0xff);             // 将地址换成8位
     
127.         eeprom_read_write_byte(Add);
     
128. 
     4 B6 F6 x, ]; p( D, _  ]2 O
129.         // 读出n个数据
     
130.         for(i=0;i<count;i++)
     
131.         {
     ) L) m) e8 l+ H$ {
132.                 *buf++ = eeprom_read_write_byte(0xff);
     
133.         }
     2 r  a- c2 ?7 }) U8 }' l
134.         eeprom_cs=1;
     
135. }

复制代码

二、测试

1. int main(void)
   
2. {        
   / e. w6 ^5 t# g
3.         u8 buf[5]={0x01,0x02,0x03,0x04,0x05},i;
   
4.         uart_init(115200);
   6 _5 ~8 M: d1 b4 e0 P5 K4 W
5.         delay_init();        
   
6.         program_led_init();        
   
7.         
   
8.         eeprom_wp=1;
   $ t/ j6 ?2 s- W/ ]4 l
9.         eeprom_init();
   ) s' t& C: o1 c+ B
10.         eeprom_write_buf(0x0000,buf,sizeof(buf));
    , v* s6 R2 _& {9 G
11. //        eeprom_write_byte(0x0000,0x08);
    ' ^; n( p) r, o& w- W
12.         memset(buf,0x00,sizeof(buf));
    : G0 x( T" j. f. Z
13.         eeprom_wp=0;
    
14.         while(1)
    
15.         {        
    
16.                
    , h6 \+ c  G$ a
17.                 eeprom_read_buf(0x0000,buf,sizeof(buf));
    
18.         //        buf[0]=eeprom_read_byte(0x0001);
    
19.                 for(i=0;i<sizeof(buf);i++)
    
20.                         printf("0x%02x ",buf<i>);
    
21.                 printf("\r\n");
    ( O# C" o- [* R$ s
22.                 memset(buf,0x00,sizeof(buf));
      X; M. ^8 X2 V# m& P
23.                
    1 c: a& g2 N5 F5 D# o" V
24.                 program_led_data(0x10,0x10,0x10);
    7 q: n2 J/ x; `6 _- m9 v
25.                 delay_ms(500);
    
26. 
    
27.                 program_led_data(0x00,0x00,0x00);
    
28.                 delay_ms(500);        
    
29.                
    0 k) }. q7 B9 p3 {$ i$ `
30.                
    4 I9 O) T) H( f# @& E8 ]0 s7 q, C0 W9 Z
31.         }
    
32. }
    
33. 
    / y4 k4 D4 c$ t6 P& g
34. 
    ! `( _8 D7 t7 \0 g6 o
35. </i>

复制代码

  p8 L2 g- l* g$ I9 l; B