1. #include "eeprom.h"
   
2. 
   
3. 
   0 ]# G) k  G/ z! z! M9 l% r# _. P
4. void eeprom_init()
   
5. {
   0 P" V; Q" E6 v
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   0 U% u! a$ P- L5 M, J" J) `
7.         SPI_InitTypeDef  SPI_InitStructure;
   
8. 
   
9.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOB时钟
   6 i" @; M3 j' Y( U: r
10.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);//使能SPI1时钟
    
11. 
    % m6 U0 R. e1 g8 a4 p( |  P
12.         //GPIOFB3,4,5初始化设置
    / A' t) g3 x  S' N9 ]( F0 r% k
13.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;//PB3~5复用功能输出        
    8 W% O8 ]$ w) ?0 H# [% H  b
14.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    
15.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    ' x- l  I' d  Y1 U: \1 z/ |) V3 d: u
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    , i, q3 u8 w% _: |" p
17.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    . V, b+ J" l' f; N! b$ E4 F
18.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
    
19.         
    ; Y* {$ P  C$ r1 A4 n# ?5 K# O0 W
20.         //GPIOFB3,4,5初始化设置
    . F6 P, i8 E0 _% y! L
21.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PB3~5复用功能输出        
    
22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    
23.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    6 q% _1 Y: a9 L9 P
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
25.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
26.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化        
    
27.         
    9 W8 K6 F7 |9 H
28.         //GPIOFB3,4,5初始化设置
    # @1 a: s  P9 D. h2 g- _  h
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;//PB3~5复用功能输出        
      A0 R% b' g3 F% {
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//复用功能
    , N0 B& x9 d; ^7 M& c1 d( F
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
32.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    4 ]. `1 F  v3 t- a' ~$ ~
33.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
34.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
    8 e; O, l( s2 o) K
35.         GPIO_SetBits(GPIOE,GPIO_Pin_2|GPIO_Pin_3);        
    
36. 
    
37.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource10,GPIO_AF_SPI2); //PB3复用为 SPI1
    . L0 I* t, D* t4 w* V
38.         GPIO_PinAFConfig(GPIOC,GPIO_PinSource2,GPIO_AF_SPI2); //PB4复用为 SPI1
    6 q' }: a# x+ s7 Y  _/ I
39.         GPIO_PinAFConfig(GPIOC,GPIO_PinSource3,GPIO_AF_SPI2); //PB5复用为 SPI1
    2 [1 v" B  C( _+ B1 \6 w
40. 
    ; C" g" P( _9 l# `4 Q" t
41.         //这里只针对SPI口初始化
    
42.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,ENABLE);//复位SPI1
    - b0 _+ S; T* p8 T. ]
43.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);//停止复位SPI1
    ( g+ x* e% }7 z/ x
44. 
    8 J- V. `. V" s
45.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    $ u5 M& J% H" g1 H* _/ A
46.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    , O+ A7 E5 @7 W7 C' t
47.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    0 n2 B3 u% Q! X; F/ F, ?
48.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    3 f7 s  _8 S1 {. M1 O3 n  ^- Q
49.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    8 V$ c* R7 h+ @' q' d
50.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    ! v' ^* w  z$ L4 C) d3 a
51.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
52.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    4 L1 v* ]$ ]2 N3 `: {# z6 J
53.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    * U( z) t- u( S* X
54.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
55. 
    
56.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    
57. 
    
58. ///        eeprom_read_write_byte(0xff);//启动传输        
    / z4 |; e/ }7 _. w% m
59. }
    
60. //SPI 速度设置函数
    
61. //SpeedSet:
    ! c9 ?. E/ G( M# x! `9 W; K
62. //SPI_BaudRatePrescaler_2   2分频   
    
63. //SPI_BaudRatePrescaler_8   8分频   
    
64. //SPI_BaudRatePrescaler_16  16分频  
    ! W7 P! [) J% o5 ?
65. //SPI_BaudRatePrescaler_256 256分频
    1 _& U3 w, O" }' X- M0 E
66. 
    % U, e# g- ^% ^1 S7 F3 N% W* z
67. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    
68. {
    * s6 @$ T8 n6 P  j/ J( r2 v
69.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    7 l5 q5 w8 i. b/ W
70.         SPI2->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    
71.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    " t. q) Q5 r! [1 t$ |
72.         SPI_Cmd(SPI2,ENABLE); //使能SPI1
    7 B8 L/ s; ^' d$ m5 \: u" Q
73. 
    
74. }
    
75. 
    
76. //SPIx 读写一个字节
    - Q8 C: J8 U3 x9 `4 J5 s$ r
77. //TxData:要写入的字节
    
78. //返回值:读取到的字节
    0 B2 r* Z8 W, s
79. u8 eeprom_read_write_byte(u8 TxData)
    
80. {               
    & o/ U) b1 `2 m6 K) X7 o" W
81.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    ; A; R; S2 H$ Q1 V$ W7 m7 z
82. 
    ' M5 g# O: [+ J5 W! }: G8 D& o9 S& u
83.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个byte  数据
    
84. 
    
85.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    ! A, B# J, X; N( ?0 X6 P2 K
86. 
    0 D+ j* F. \: e# Y9 I  E; D6 {& I) R
87.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                    
    
88. }
    ! x$ W. t# O$ y+ @7 C
89. 
    8 p' J+ [5 g+ W, L
90. //==============================================================================
    2 Z1 n- o' u* j/ ^5 X! }% s$ Z
91. // 描述: 在AT25读状态寄存器
    
92. // 输入: 无
    3 b" o0 T/ ^! T$ A
93. // 返回: unsigned char dat 状态寄存器数据
    ( [; c7 ]( \- |% K6 @
94. //==============================================================================
    + x' N2 S% Q& {4 H& T
95. 
    % W% Z( e% i* P5 N) x) m$ r5 D: P
96. 
    
97. u8 eeprom_read_sr(void)
    
98. {
    
99.         u8 dat;
    
100.         eeprom_cs=0;
     
101.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
     
102.         dat = eeprom_read_write_byte(0xff);       //  读回数据
     
103.         eeprom_cs=1;
     ; Z+ }  r+ r0 J- M: U$ O
104.         return  dat;
     
105. }
     " G9 h8 W+ y) E0 @0 O
106. 
     
107. //==============================================================================
     
108. // 描述: 向AT25写入一个数据
     ' W& b' T! ]) r" [6 e4 h
109. // 输入: unsigned char Dat 字符数据
     
110. //       unsigned int addr 写入的地址
     
111. // 返回: 无
       A- n7 A4 X& y! X/ K8 D8 H
112. //==============================================================================
     0 z4 z7 Y6 E' J( N) U5 m/ k
113. void eeprom_write_byte(u16 addr,u8 Dat)
     
114. {
     & L! ?' g  Q. \% @0 a
115.         unsigned char Add;
     
116.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
       {( }- Y5 k# k' `
117.         
     
118.         eeprom_cs=0;
     
119.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     & y  N8 h- y* u3 S; {
120.         eeprom_cs=1;
     , b6 g1 ~: L$ S
121.         
     
122.         eeprom_cs=0;                                  // 芯片使能
     
123.         // 写入写操作指令
     
124.         if(addr>0x00ff)
     0 G$ Z7 l; r* p( |3 K
125.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
     
126.         else
     
127.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
     ' L; Q; R% J6 `  N9 O8 i( \* E
128. 
     
129.         // 写入地址
     6 ]* _3 e) G1 v  L+ I9 i, \
130.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     , H, O/ M" M+ s3 n% a% D$ X4 J5 V5 I
131.         eeprom_read_write_byte(Add);
     
132. 
     6 ?5 M/ A. ~2 m. X' u: l* d  q
133.         // 写入数据
     ! H( O8 P4 \' z3 n5 ^8 i2 q
134.         eeprom_read_write_byte(Dat);
     
135.         eeprom_cs=1;                                // 芯片关闭   
     3 M$ k) }1 m' g1 u. ?9 m& \
136. }
     
137. //==============================================================================
       ~3 ~7 T. n( H! D
138. // 描述: 在AT25读一个字节操作
     . N$ G8 p5 H9 ^/ ~
139. // 输入: 无
     
140. // 返回: unsigned char dat 读出一个字符数据
     
141. //==============================================================================
     5 l3 j8 O5 g: C4 ?# i) P) X' p5 W$ H
142. u8 eeprom_read_byte(u16 addr)
     
143. {
     
144.         u8 dat,add;
     
145.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
146.         eeprom_cs=0;
     - o1 u3 J. I' ~9 ]) B* U; Z3 I
147.         // 写入写操作指令
     
148.         if(addr>0x00ff)
     
149.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     . ]% ^) U1 u$ Y8 e4 o
150.         else
     
151.                 eeprom_read_write_byte(READ);                  // 地址小于255
     
152. 
     
153.         // 写入地址
     3 R# o$ J/ [" J
154.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     7 f# A/ K, S, L- Y- ]% N
155.         eeprom_read_write_byte(add);
     8 _6 R0 c9 X; h0 R
156. 
     
157.         // 读出一个数据
     % t3 |. Z/ c6 H2 E. \- x# E! D/ x( n
158.         dat=eeprom_read_write_byte(0xff);
     
159.         eeprom_cs=1;
     2 B3 i1 \( q$ U) O) _
160.         return dat;
     - m0 e6 T. S. F! T: m1 ^
161. }
     
162. //==============================================================================
     4 ?$ o% F. }! J6 h/ i, b4 f6 R
163. // 描述: 向AT25连续写入数据
     
164. // 输入: unsigned char *PC 写入数据指针
     
165. //       unsigned int count 写入数量计数  
     
166. //       unsigned int SatAddr 写入起始地址
     
167. // 返回: 无
     
168. //==============================================================================
     + c( x( ^8 p- l6 x
169. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
     6 K  Y# Y$ B, |
170. {
     ) k6 k. _( x" x4 M" a0 J
171.         u16 i;
     
172.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     " ]- z" Q, i6 x( b
173. 
     - v/ J4 {; O$ F5 `+ a
174.         eeprom_cs=0;
     
175.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     
176.         eeprom_cs=1;
     
177.         eeprom_cs=0;
     / [9 P: u, k- b
178.         
     ) C+ ~+ x' O0 |3 k* I4 K1 X
179.         eeprom_read_write_byte(WRITE);                        // 写入写操作指令
     ' |( k( h5 O( f% A6 ^$ `& Q% ^
180.         eeprom_read_write_byte(startAddr>>8);                 // 写入地址
     
181.         eeprom_read_write_byte(startAddr);
     
182. 
     : T3 \0 A5 L: \5 E8 [6 E
183.         for(i=0;i<count;i++)// 写入数据
       y* L  R* x. w1 N  S8 {
184.         {
     : {. q" k% Z6 ?1 _
185.                 eeprom_read_write_byte(*buf++);
     . k2 E8 i- E0 P3 P  N9 g
186.         }
     9 s* K, t2 [( h" h& o7 D
187.         eeprom_cs=1;                                 // 芯片关闭   
     , r: b, q4 l7 a# F% `' Z8 Q+ X* T) d; N# f
188. }
     
189. //==============================================================================
     
190. // 描述: 向AT25连续写入n字节的数据
     1 |' F# x# U% ~/ T$ {+ D+ p) c5 k
191. // 输入: unsigned char *PC 写入数据指针
     
192. //       unsigned int count 写入数量计数  
     % N) V  l9 u& p0 O! ~1 I* c6 I
193. //       unsigned int SatAddr 写入起始地址
     6 _% O1 h% \( s( O! T: t3 P
194. // 返回: 无
     , B) `" t3 z7 ~0 n' ?! V- I4 }
195. //==============================================================================
     4 d! g' `8 H" n/ c. [# h: e8 T
196. void eeprom_write_nbyte(u16 startAddr,u8 *buf,u16 count)
     
197. {
     
198.         u16 pageTotal=count/64;
     
199.         u16 pageResidue=count%64;
     
200.         u16 i;
     + O, L7 G. i' f3 Q  g: S: |4 G/ I3 f6 I
201.         u16 pageCnt=0;
     / R3 ?$ S' r7 U) \$ ]8 a. n) b
202.         
     ( E1 O" P) H1 d
203.         for(i=0;i<pageTotal;i++)
     " c4 W% I# p8 Z7 r( _9 v1 W3 t
204.         {
     0 Y7 ]1 w$ ]4 z
205.                 eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],64);
     
206.                 pageCnt+=64;
     
207.         }
     
208.         eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],pageResidue); //写入剩余的
     
209. }
     * Z5 r1 w( F" x+ n8 w" W
210. 
     $ r' s$ z2 P; k  C& T
211. 
     
212. //==============================================================================
     " L# h# [# ^+ u( S5 R
213. // 描述: 在AT25连续读数据
     ' h2 z9 n. V1 j" O* q& \3 z
214. // 输入: unsigned char *PC 读出数据指针
     
215. //       unsigned int count 读出数量计数  
     7 g6 I; v/ _( ~0 M
216. //       unsigned int SatAddr 读出起始地址
     1 n( l) x' U' u  o
217. // 返回: 无
     
218. //==============================================================================
     : E3 H  Z9 ]; i4 j* B! W/ i
219. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     
220. {
     
221.         unsigned int i;
     
222.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
223.         eeprom_cs=0;
     ( n% m2 z! p' a  ?7 K
224.         
     
225.         eeprom_read_write_byte(READ);       // 写入读操作指令           
     
226.         // 写入地址
     
227.         eeprom_read_write_byte(startAddr>>8);
     : u' `$ r* t0 B
228.         eeprom_read_write_byte(startAddr);
     ' y. q( |, U4 n7 f4 r# u
229. 
     
230.         // 读出n个数据
     # d) x+ r8 ^& I+ s/ @# @" f' e! a
231.         for(i=0;i<count;i++)
     $ ]) y' s5 A  ?# @" E& u
232.         {
     
233.                 *buf++ = eeprom_read_write_byte(0xff);
     : d9 i( \5 ]" ^: s; Z
234.         }
     
235.         eeprom_cs=1;
     
236. }
     * x6 b- n( c+ r* r( \/ N7 z! W7 s
237. 
     ! x" V/ b/ h7 m7 u" L1 z0 D
238. 
     

复制代码