一、源代码
) }! e$ v6 F+ h( J% O% U* T' J

1. void eeprom_init()
   
2. {
   . Y: U# S4 X7 D; y" w# {
3.         GPIO_InitTypeDef GPIO_InitStructure;
   
4.          SPI_InitTypeDef  SPI_InitStructure;
     h; b5 g; b' ]; K$ v: v% u8 }
5.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
   6 e- S0 P8 y) B; Z8 I1 }
6. 
   
7.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12;  // PB12 推挽
   
8.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
   ; H; r3 U& j1 u* A! p* X
9.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
10.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    3 i/ }. L* }& Z# @
11.         GPIO_SetBits(GPIOB,GPIO_Pin_11|GPIO_Pin_12);
    1 [& N2 j7 {, f1 F: _1 S
12. 
    
13. 
    * [' @* o# E5 i  D+ `2 B
14. 
    5 `0 o6 o8 d: r1 ~
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
    / R- T% b( [& x- [
16.         RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能         
    
17. 
    
18.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    
19.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出
    3 @9 k* g6 Z( D, _) g4 Z) Z
20.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
    3 b6 }4 t+ Q9 ^# F2 I7 J; c
22. 
    2 S5 `; ?4 {& v
23.          GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉
    % y* i( \  Z5 T! j6 Q/ z) C- f
24. 
    + U! J0 G( s2 T: C# J9 G, }; \
25.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    ! b- ]/ f9 S# W9 g+ F! H3 D
26.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    5 B4 S; U! {9 k7 y# v1 G$ }
27.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
28.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    
29.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
      D8 g3 G4 _; B( n' R" j
30.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    5 ]! M: Y' [7 a3 ^& Y& s
31.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
32.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
33.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
34.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    , b0 A7 q4 d1 ]1 d( {, ?6 y) Q3 h
35. 
    4 o9 ]' A- Y9 Q0 [/ d- `7 f
36.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    7 B5 j% U# n0 J& r  s7 T& G: q
37.         
    1 {( S6 t+ W7 U7 S- `5 p# H
38.         eeprom_read_write_byte(0xff);//启动传输               
    7 B/ ], X5 n8 y8 t3 r/ Q
39. }
    
40. //SPI 速度设置函数
    ' O' w8 A6 V- c+ @6 @- [4 p
41. //SpeedSet:
    - V' D2 w/ m, d- g9 l' \. X
42. //SPI_BaudRatePrescaler_2   2分频   
    0 w0 |* p) H" A
43. //SPI_BaudRatePrescaler_8   8分频   
    ( |6 _4 e. C6 y" t
44. //SPI_BaudRatePrescaler_16  16分频  
    & y1 }$ x9 u$ c' L4 ~
45. //SPI_BaudRatePrescaler_256 256分频
    
46. 
    - C- w  N0 _  I1 F0 ~* E3 }
47. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    0 @% K. `% H( C& H" E2 }/ I& z- x3 S
48. {
    ! Y% c* _; {8 G6 u
49.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    
50.         SPI2->CR1&=0XFFC7;
    $ }8 `/ j6 G/ p( d
51.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI2速度
    ! }5 r9 d" v) W* O
52.         SPI_Cmd(SPI2,ENABLE);
    
53. 
    
54. }

复制代码

1. //SPIx 读写一个字节
   
2. //TxData:要写入的字节
   
3. //返回值:读取到的字节
   
4. u8 eeprom_read_write_byte(u8 TxData)
   
5. {               
   
6.         u8 retry=0;                                         
   $ w( F  |; |0 A0 \( Y- i$ T$ N
7.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
   ) Y1 @% H" D1 V, G
8.                 {
   
9.                 retry++;
   
10.                 if(retry>200)return 0;
    
11.                 }                          
    
12.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
    % n) d- s% s3 `
13.         retry=0;
    1 M9 [7 N2 {. D
14. 
    : y& n3 D- [, Z8 g# g1 z( h' W0 N" g
15.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    ; p# H; o( a9 g! J, ~. z
16.                 {
    / x0 C7 l8 P5 _, S- b. j6 I
17.                 retry++;
    / j2 F: |6 r# o# |
18.                 if(retry>200)return 0;
    ! v1 y4 ]. [! b7 P
19.                 }                                                              
    
20.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
    
21. }

复制代码

1. //==============================================================================
   % l% l0 e. H$ ^8 V/ \
2. // 描述: 在AT25读状态寄存器
   + H$ y1 d$ e8 m1 R
3. // 输入: 无
   + P, @2 D/ f+ c0 z6 S2 K# ^8 y
4. // 返回: unsigned char dat 状态寄存器数据
   
5. //==============================================================================
   ' f" X5 c& L$ c7 N1 X$ t
6. 
   
7. 
   + h/ Y/ o. D6 d3 n
8. u8 eeprom_read_sr(void)
   + K3 O0 h5 ?. j0 Z& \7 ?
9. {
   
10.         u8 dat;
    
11.         eeprom_cs=0;
    # ]) J- ^& ]6 Q9 L1 }; {
12.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
    8 k' B& @' m+ U/ g( E4 p3 }
13.         dat = eeprom_read_write_byte(0xff);       //  读回数据
    
14.         eeprom_cs=1;
    3 f' }! W1 z1 @. w. G; Y) O! i
15.         return  dat;
    9 {4 k7 W! h1 b) n! ?4 Z
16. }
    0 a* @( ^1 S, C& m1 Y
17. 
    
18. //==============================================================================
    
19. // 描述: 向AT25写入一个数据
    8 H, e& w# `9 Y
20. // 输入: unsigned char Dat 字符数据
    + F* A8 P( {8 U
21. //       unsigned int addr 写入的地址
    
22. // 返回: 无
    : I. m, u9 c8 Z4 e
23. //==============================================================================
    
24. void eeprom_write_byte(u16 addr,u8 Dat)
    5 Y1 u' R5 r5 [* B9 ]/ s
25. {
    # {! u( V) _5 P. j" Q, q) v
26.         unsigned char Add;
    ( S6 \; D* j7 E6 e; x
27.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
    ( [8 Z: L8 V' B, f
28.         
    
29.         eeprom_cs=0;
    
30.         eeprom_read_write_byte(WREN);                           // 写使能锁存
    3 ]) b: b/ ^/ @) G( {
31.         eeprom_cs=1;
    
32.         
    
33.         eeprom_cs=0;                                  // 芯片使能
    
34.         // 写入写操作指令
    4 T" J' Z0 ]1 x+ y
35.         if(addr>0x00ff)
    7 `' f8 l* L/ Z
36.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
    . P4 _+ }! w8 Y8 x6 T
37.         else
      q' Y5 W  g' ]) p7 Z" }
38.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
    . W7 c: t; I1 \* a5 z4 g2 o
39. 
    & r9 g' y$ o$ C, E) f0 y
40.         // 写入地址
    
41.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
    4 U3 w/ m1 z9 X- i7 n/ @
42.         eeprom_read_write_byte(Add);
    $ t3 v. A% a7 a$ f
43. 
    7 c% W6 B" G' p4 x
44.         // 写入数据
    , _/ F6 Z6 W0 ?+ l
45.         eeprom_read_write_byte(Dat);
    
46.         eeprom_cs=1;                                // 芯片关闭   
    
47. }
    ! X6 q& m7 F) ^3 n" p" H9 a
48. //==============================================================================
    ! A' R; Z2 J: `! N( x3 E" k9 N, p" ]
49. // 描述: 在AT25读一个字节操作
    
50. // 输入: 无
    & S! n: c9 R2 S; [
51. // 返回: unsigned char dat 读出一个字符数据
    
52. //==============================================================================
    
53. u8 eeprom_read_byte(u16 addr)
    
54. {
    
55.         u8 dat,add;
    # j! I) F. O* m/ i) Y/ W
56.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
    % s* X3 H; F% O5 c5 f
57.         eeprom_cs=0;
    
58.         // 写入写操作指令
    
59.         if(addr>0x00ff)
    
60.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
    7 G% r: i$ ^9 k; Z
61.         else
    
62.                 eeprom_read_write_byte(READ);                  // 地址小于255
    7 q7 \7 b* P& q+ X2 ?5 Z/ W
63. 
    7 ^5 v3 Y- b9 @, `* M
64.         // 写入地址
    
65.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
    
66.         eeprom_read_write_byte(add);
    * X5 }- S0 ]4 d! Z3 G
67. 
    
68.         // 读出一个数据
    
69.         dat=eeprom_read_write_byte(0xff);
    / r+ N4 \9 n4 C1 e3 o. D' `
70.         eeprom_cs=1;
    5 S" v; H0 d% {' C! _) ?
71.         return dat;
    
72. }
    * z# k, Z' l# p7 A
73. //==============================================================================
    
74. // 描述: 向AT25连续写入数据
    
75. // 输入: unsigned char *PC 写入数据指针
    
76. //       unsigned int count 写入数量计数  
    
77. //       unsigned int SatAddr 写入起始地址
    
78. // 返回: 无
    
79. //==============================================================================
    
80. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
    
81. {
    
82.         u8 Add;
    
83.         u16 i;
    $ r5 D9 k1 ^- c% g
84.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
    3 S( Z* z7 B3 ^8 G
85. 
    
86.         eeprom_cs=0;
    
87.         eeprom_read_write_byte(WREN);                           // 写使能锁存
    
88.         eeprom_cs=1;
    
89.         eeprom_cs=0;
    3 Z" m$ o. \- S5 {
90.         // 写入写操作指令
    2 n# ]5 m8 J; x9 [5 V- H
91.         if(startAddr>0x00ff)
    
92.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
    
93.         else
    
94.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
    # c# D5 g  s  R/ k: w
95. 
    
96.         // 写入地址
    
97.         Add = (unsigned char)(startAddr & 0xff);             // 将地址换成8位
    
98.         eeprom_read_write_byte(Add);
    
99. 
    ( Z' A7 z0 j* d5 h4 }
100.         for(i=0;i<count;i++)// 写入数据
     
101.         {
     
102.                 eeprom_read_write_byte(*buf++);
     & D3 e5 n$ ~' P* E5 I% H: b' L
103.         }
     
104.         eeprom_cs=1;                                 // 芯片关闭   
     ; p. q, z2 u* b0 Y0 k
105. }
     
106. //==============================================================================
     ! E. x# g! p$ p" E* d
107. // 描述: 在AT25连续读数据
     
108. // 输入: unsigned char *PC 读出数据指针
     ' p0 @% l  V7 h) p9 R) h
109. //       unsigned int count 读出数量计数  
     
110. //       unsigned int SatAddr 读出起始地址
     8 M, w* r+ M1 f4 [
111. // 返回: 无
     5 @) [: x9 p- D9 [
112. //==============================================================================
     
113. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     , v( H0 k0 d) h+ W
114. {
     0 K5 `! z6 D2 B0 Q
115.         unsigned char Add;
     
116.         unsigned int i;
     
117.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
118.         eeprom_cs=0;
     
119.         // 写入写操作指令
     
120.         if(startAddr>0x00ff)
     8 Y/ ]5 g# V, l! w0 s9 H3 a
121.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     
122.         else
     
123.                 eeprom_read_write_byte(READ);                  // 地址小于255
     
124. 
     0 h& t3 a$ U" c$ R: p6 p& n: ~
125.         // 写入地址
     - M, U$ m. [5 l1 _
126.         Add = (unsigned char)(startAddr & 0xff);             // 将地址换成8位
     
127.         eeprom_read_write_byte(Add);
     
128. 
     , I+ W7 J. m: ^8 V2 ~  _- ?  x" P- A1 d0 ~& m
129.         // 读出n个数据
     
130.         for(i=0;i<count;i++)
     
131.         {
     + @  O/ \3 Q2 T( d2 J. P
132.                 *buf++ = eeprom_read_write_byte(0xff);
     3 z  l# m* t2 t6 l
133.         }
     
134.         eeprom_cs=1;
       c4 g. n' u" ]9 l, j6 l& \
135. }

复制代码

% A" @& [+ L/ Z  j. N: @; q二、测试
( v# D! q, m: }+ ]4 V( y

1. int main(void)
   0 M" n* y3 i8 E" L$ [
2. {        
   
3.         u8 buf[5]={0x01,0x02,0x03,0x04,0x05},i;
   
4.         uart_init(115200);
   7 @  y! p- y* V- g3 g5 g
5.         delay_init();        
   
6.         program_led_init();        
   
7.         
   
8.         eeprom_wp=1;
     D& S2 j9 @  w" s3 R$ Q( K
9.         eeprom_init();
   7 Z" F' E" ]; B
10.         eeprom_write_buf(0x0000,buf,sizeof(buf));
    
11. //        eeprom_write_byte(0x0000,0x08);
    
12.         memset(buf,0x00,sizeof(buf));
      R+ A5 d/ c/ f3 L* l8 k
13.         eeprom_wp=0;
    2 b- c# _* k4 ^1 {  d+ h
14.         while(1)
    / x. s5 ^$ G+ ]$ o" a
15.         {        
    . m3 S$ [$ W0 B  K8 D7 Y( E5 P
16.                
    3 {6 k; ?  z, |" ~. R3 a% O9 N/ q
17.                 eeprom_read_buf(0x0000,buf,sizeof(buf));
    2 u+ Z- D3 T& i
18.         //        buf[0]=eeprom_read_byte(0x0001);
    
19.                 for(i=0;i<sizeof(buf);i++)
    - V" K9 D0 ?, y. u
20.                         printf("0x%02x ",buf<i>);
    
21.                 printf("\r\n");
    
22.                 memset(buf,0x00,sizeof(buf));
    ! Y. J" E% J5 N4 g  }) d
23.                
    / S3 r( H4 W: P  D5 v% K9 h" ]
24.                 program_led_data(0x10,0x10,0x10);
    4 o) O  W- V& L: w
25.                 delay_ms(500);
    : v  n3 Q+ g' Q# t, L1 A5 J$ ~
26. 
    , |( L+ e3 D! Q7 G
27.                 program_led_data(0x00,0x00,0x00);
    
28.                 delay_ms(500);        
    
29.                
    
30.                
    
31.         }
    
32. }
    
33. 
    
34. 
    
35. </i>

复制代码

2 u" g* n$ Z4 J6 o% Q. u