1. #include "eeprom.h"
   : p; N: Q. i( |
2. 
   ) G! y4 _( v  i$ ?- Z! L
3. 
   
4. void eeprom_init()
   & m1 p2 O; \; ^" e
5. {
   8 P; w% F  ~9 G& E3 m9 D
6.         GPIO_InitTypeDef  GPIO_InitStructure;
     w; Y! |( J% N' s+ m* z( }: C
7.         SPI_InitTypeDef  SPI_InitStructure;
   . l, b5 o/ v6 T1 |
8. 
   
9.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOB时钟
   ' b% E, b  u! O; K8 X$ H, w# K/ S
10.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);//使能SPI1时钟
    
11. 
    6 h8 X5 @- k2 x& d4 f! S
12.         //GPIOFB3,4,5初始化设置
    
13.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;//PB3~5复用功能输出        
    
14.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    : G; v$ W; Q6 H, Q# X
15.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    3 o5 j1 i+ c, O( }1 @1 H
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
17.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
18.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
    ! j4 p3 Q, ^: v9 ?* _
19.         
    5 P: J* J# K4 _- T) V
20.         //GPIOFB3,4,5初始化设置
    3 C$ B  c/ e- I2 R, I- Z) i
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;//推挽输出
    + t/ u$ Z1 j6 }
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
      p' t& `6 ]4 Q8 D
25.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
26.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化        
    $ k) I* {& U; |1 S0 a7 x" m5 F6 T5 v
27.         
    
28.         //GPIOFB3,4,5初始化设置
    - A+ ~$ R$ I4 [$ W# ^0 ]
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;//PB3~5复用功能输出        
    
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//复用功能
    
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    & z' _5 `$ n7 ]( [
32.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    & g' {$ N7 _, q0 d& v
33.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
34.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
    2 k8 T+ L6 p" v8 c& C, z# d
35.         GPIO_SetBits(GPIOE,GPIO_Pin_2|GPIO_Pin_3);        
    
36. 
    
37.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource10,GPIO_AF_SPI2); //PB3复用为 SPI1
    5 ?6 I; Y) N, T% |, [/ s
38.         GPIO_PinAFConfig(GPIOC,GPIO_PinSource2,GPIO_AF_SPI2); //PB4复用为 SPI1
    
39.         GPIO_PinAFConfig(GPIOC,GPIO_PinSource3,GPIO_AF_SPI2); //PB5复用为 SPI1
    % W4 d7 Q" \4 \: x5 y
40. 
    
41.         //这里只针对SPI口初始化
    
42.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,ENABLE);//复位SPI1
    
43.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);//停止复位SPI1
    0 ]. l; o' _% O: Q" J* w3 M/ y/ v7 f
44. 
    , K! k  Z( N& r; n: s) e, _
45.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
46.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    
47.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    - ^7 h4 `& T  X3 F) }
48.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    
49.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    ( R6 j, Z$ S1 c2 i5 X
50.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    7 _5 T+ _. W: `3 R' `% n4 q
51.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
52.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
53.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    4 S$ n/ [& q% A  d" ]
54.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
55. 
    ( z+ E' C2 d# `. w
56.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    
57. 
    0 E) p; v! C& }2 H
58. ///        eeprom_read_write_byte(0xff);//启动传输        
    7 x0 n2 E1 p9 a: W4 q4 i" m
59. }
    ; d  z3 x2 U) ?5 G
60. //SPI 速度设置函数
    
61. //SpeedSet:
    
62. //SPI_BaudRatePrescaler_2   2分频   
    
63. //SPI_BaudRatePrescaler_8   8分频   
    6 ^0 f8 z. P! z; c) f2 H! j
64. //SPI_BaudRatePrescaler_16  16分频  
    " r* v  `$ A- U& z% v" Y  {& _/ J
65. //SPI_BaudRatePrescaler_256 256分频
    
66. 
    
67. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    
68. {
    5 R  _- W7 E. ~% I4 u
69.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    
70.         SPI2->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    
71.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    / Y# l3 f4 w; [: {/ x
72.         SPI_Cmd(SPI2,ENABLE); //使能SPI1
    
73. 
    0 ]- b7 S, \5 y+ b1 z
74. }
    
75. 
    
76. //SPIx 读写一个字节
    
77. //TxData:要写入的字节
    
78. //返回值:读取到的字节
    # J$ L" ]! U* Y% y% m
79. u8 eeprom_read_write_byte(u8 TxData)
    : c: t" R+ p- N, q2 K7 O
80. {               
    
81.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    
82. 
    + P, Q/ g8 x1 E
83.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个byte  数据
    
84. 
    ; ]0 x6 A; `; s) L3 i
85.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    / C( g2 M) M3 U" k8 p
86. 
    4 Z$ j! r9 b; A0 e2 l/ m) y
87.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                    
    
88. }
    
89. 
    5 n) P9 e6 |# e% x2 A* U; u. V; ?
90. //==============================================================================
    
91. // 描述: 在AT25读状态寄存器
    
92. // 输入: 无
    
93. // 返回: unsigned char dat 状态寄存器数据
    
94. //==============================================================================
    
95. 
    8 ?* s7 ]% E% T
96. 
    5 r, i* O' j$ V
97. u8 eeprom_read_sr(void)
    
98. {
    
99.         u8 dat;
    
100.         eeprom_cs=0;
     
101.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
     * z/ o9 A1 B$ N( x) G# v
102.         dat = eeprom_read_write_byte(0xff);       //  读回数据
     , A; z# D8 L0 V8 ~1 T0 {
103.         eeprom_cs=1;
     ' B) E/ U; f. N4 u6 G
104.         return  dat;
     9 |1 I, m7 l2 V4 i5 ^
105. }
     & i, E( r. q# M( N: Y: j2 w
106. 
     
107. //==============================================================================
     2 k' r/ q' ?% |1 M
108. // 描述: 向AT25写入一个数据
     ' j% r2 V) w* N4 n
109. // 输入: unsigned char Dat 字符数据
     
110. //       unsigned int addr 写入的地址
     
111. // 返回: 无
     . |  m- s. |/ C' Y/ }5 U) W
112. //==============================================================================
     
113. void eeprom_write_byte(u16 addr,u8 Dat)
     3 J8 o/ ^) s2 {
114. {
     
115.         unsigned char Add;
     8 ^# a2 \! V! Q: K$ u8 D  H% q6 V
116.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     
117.         
     
118.         eeprom_cs=0;
     & J8 m0 E8 A3 S3 v) C* p7 O; L
119.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     
120.         eeprom_cs=1;
     
121.         
     3 W  R; U  l9 C8 p
122.         eeprom_cs=0;                                  // 芯片使能
     ; Z" E$ b7 z) M; v' D: u
123.         // 写入写操作指令
     
124.         if(addr>0x00ff)
     * g' u( b0 f; F* G1 c
125.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
     
126.         else
     
127.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
     
128. 
     
129.         // 写入地址
     $ Z# r4 t' q! E  {0 M) N  ?
130.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     3 \% o/ D8 |3 j$ m% A% ~
131.         eeprom_read_write_byte(Add);
     & K3 M* }# A1 T) \9 O
132. 
     
133.         // 写入数据
     0 p# X; R7 M0 M/ F! I9 E$ g+ F" O
134.         eeprom_read_write_byte(Dat);
     
135.         eeprom_cs=1;                                // 芯片关闭   
     
136. }
     
137. //==============================================================================
     0 E# H. P* x" Z* c3 D$ {
138. // 描述: 在AT25读一个字节操作
     ( O3 b+ b) s3 s1 s# r  p
139. // 输入: 无
     ) v8 N1 M4 I0 c5 N
140. // 返回: unsigned char dat 读出一个字符数据
     4 c, V. B& W' P7 x4 Q  j" S
141. //==============================================================================
     6 R- h% |7 `- R$ s
142. u8 eeprom_read_byte(u16 addr)
     
143. {
     
144.         u8 dat,add;
     
145.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
146.         eeprom_cs=0;
     : ]3 E( @* X- H9 R4 E1 i# `
147.         // 写入写操作指令
     
148.         if(addr>0x00ff)
     
149.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     ' o/ Q3 R1 _: _- C5 F
150.         else
     / |8 Q, a% e  E* v/ S
151.                 eeprom_read_write_byte(READ);                  // 地址小于255
     ' O. v- }1 ?" a
152. 
     
153.         // 写入地址
     
154.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     
155.         eeprom_read_write_byte(add);
     . ~  s: K" Q( q$ |
156. 
     
157.         // 读出一个数据
     5 U2 f2 \  K: U6 F& C
158.         dat=eeprom_read_write_byte(0xff);
     
159.         eeprom_cs=1;
     
160.         return dat;
     
161. }
     
162. //==============================================================================
     1 b7 `- L& i* H
163. // 描述: 向AT25连续写入数据
     
164. // 输入: unsigned char *PC 写入数据指针
     8 V* C& S4 }) m' d5 W
165. //       unsigned int count 写入数量计数  
     
166. //       unsigned int SatAddr 写入起始地址
     
167. // 返回: 无
     2 w9 M: ]6 q* B( ^& a' i
168. //==============================================================================
     % z) X) p* n  Q0 Y
169. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
     & n1 l+ R2 }6 S5 l, o9 Z2 F- Y
170. {
     
171.         u16 i;
     0 y8 Z) a! W! [" c8 e; Q& P
172.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     - T0 }' i( x4 _$ ]. a# g2 J" p; r
173. 
     7 g) e3 l3 S2 _6 {% z' E
174.         eeprom_cs=0;
     
175.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     
176.         eeprom_cs=1;
     7 w, S+ q. s/ T3 U
177.         eeprom_cs=0;
     
178.         
     
179.         eeprom_read_write_byte(WRITE);                        // 写入写操作指令
     / d$ H) d7 S8 o4 Y* h
180.         eeprom_read_write_byte(startAddr>>8);                 // 写入地址
     / P% i' `. j5 e, _
181.         eeprom_read_write_byte(startAddr);
     
182. 
     
183.         for(i=0;i<count;i++)// 写入数据
     ( C3 R( j5 E8 H: f& Y3 f
184.         {
     
185.                 eeprom_read_write_byte(*buf++);
     
186.         }
     ! j$ O  v, X5 ~& l
187.         eeprom_cs=1;                                 // 芯片关闭   
     2 o7 `$ P" t% m+ ?, d5 F& `
188. }
     ! c9 @" r* X5 f$ v
189. //==============================================================================
     
190. // 描述: 向AT25连续写入n字节的数据
     . u9 ?* S0 k( q6 w
191. // 输入: unsigned char *PC 写入数据指针
     
192. //       unsigned int count 写入数量计数  
     6 @8 M7 m" l4 |. n  C. c; o. w
193. //       unsigned int SatAddr 写入起始地址
     
194. // 返回: 无
     
195. //==============================================================================
     
196. void eeprom_write_nbyte(u16 startAddr,u8 *buf,u16 count)
     ) {" s5 _- Q: O0 s- Y8 g7 Q3 {6 g
197. {
     
198.         u16 pageTotal=count/64;
     7 x/ b3 g3 Z  \! x& u: r1 T) ]  G8 c
199.         u16 pageResidue=count%64;
     2 P* ]7 I7 e! Y7 _8 p- ?
200.         u16 i;
     / d1 O  v! w' w7 W7 @$ y
201.         u16 pageCnt=0;
     
202.         
     * R: T8 W; P  J4 b7 @
203.         for(i=0;i<pageTotal;i++)
     ' E9 e, O" b; w. j
204.         {
     ) \" ^% z/ }0 c) {" h& l" e$ X
205.                 eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],64);
     , a1 S2 ^$ H# W5 _+ W, r
206.                 pageCnt+=64;
     
207.         }
       \2 q4 U% A  e5 e* l2 A9 y( o
208.         eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],pageResidue); //写入剩余的
     & ?8 [2 ]5 F$ q( M2 p, Q
209. }
     
210. 
     ! R# ^! }1 X/ m4 O3 C  u2 W  F& m
211. 
     ( d  j+ @! F$ q/ m0 ?/ H
212. //==============================================================================
     
213. // 描述: 在AT25连续读数据
     
214. // 输入: unsigned char *PC 读出数据指针
     
215. //       unsigned int count 读出数量计数  
     
216. //       unsigned int SatAddr 读出起始地址
     ' i( P  ^" I8 K, }
217. // 返回: 无
     
218. //==============================================================================
     
219. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     % T$ H1 i+ ^( B6 \8 Y% j
220. {
     % g2 f6 j4 g) p6 k1 R% u) b* u* N( d0 i
221.         unsigned int i;
     
222.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     ) x$ b; t) k: N5 M2 {
223.         eeprom_cs=0;
     
224.         
     + ?3 V- I9 I& Y2 F- \& C1 U$ i
225.         eeprom_read_write_byte(READ);       // 写入读操作指令           
     2 E$ h6 ?( f( M' o! I6 M
226.         // 写入地址
     
227.         eeprom_read_write_byte(startAddr>>8);
     
228.         eeprom_read_write_byte(startAddr);
     
229. 
     
230.         // 读出n个数据
     
231.         for(i=0;i<count;i++)
     4 j# ^+ J% L+ `$ E% L' N
232.         {
     7 z% ]+ }0 k6 j% y# O
233.                 *buf++ = eeprom_read_write_byte(0xff);
     
234.         }
     
235.         eeprom_cs=1;
     
236. }
     # o" M. t& H- U6 V
237. 
     9 Q2 r7 X/ y& c* O) U
238. 
     ( K4 S. Y4 z' u. w, w* w- b0 M

复制代码