1. #include "eeprom.h"
   . q" h4 _& {6 Q5 S8 M- E# V' |
2. 
   3 Y( C+ t& |, p) O: ~
3. 
   % b" U& J# @6 u, R
4. void eeprom_init()
   6 S, e* t9 i# w. B% V) y
5. {
   
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   ( {) m) m$ h' @) G
7.         SPI_InitTypeDef  SPI_InitStructure;
   
8. 
   
9.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOB时钟
   ' b# I) D! g! c; N& x
10.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);//使能SPI1时钟
    " j; M. f/ y! X% K
11. 
    + z# S4 }: f& _" b5 z' W4 u1 T
12.         //GPIOFB3,4,5初始化设置
    6 V  `% k7 h+ n" @# `. u( P
13.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;//PB3~5复用功能输出        
    
14.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    & h$ V5 n+ I6 R1 U/ k5 b  \$ {
15.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
      n  N9 E, J$ a2 |+ t  S3 t* p
17.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    # N2 J/ ~( M5 Z2 p  Y+ L7 Q
18.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
    / T( b) G9 F" f
19.         
    ( q! t* {1 t* F! T! f8 o
20.         //GPIOFB3,4,5初始化设置
    
21.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PB3~5复用功能输出        
    / i) V5 N- R$ P+ @0 A4 g2 }
22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    
23.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    & O8 W+ H, l" o
25.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
26.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化        
    
27.         
    / |8 k7 l* O! x% r
28.         //GPIOFB3,4,5初始化设置
    2 X; h1 Z. l4 ^$ q# S9 w6 s6 g
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;//推挽输出
    
32.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    ; }; P( z1 a6 S. d) i
33.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
34.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
    
35.         GPIO_SetBits(GPIOE,GPIO_Pin_2|GPIO_Pin_3);        
    0 v" h5 D! Y& W# r
36. 
    
37.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource10,GPIO_AF_SPI2); //PB3复用为 SPI1
    
38.         GPIO_PinAFConfig(GPIOC,GPIO_PinSource2,GPIO_AF_SPI2); //PB4复用为 SPI1
    
39.         GPIO_PinAFConfig(GPIOC,GPIO_PinSource3,GPIO_AF_SPI2); //PB5复用为 SPI1
    
40. 
    . r: X, F8 i5 a! s( w/ c
41.         //这里只针对SPI口初始化
    
42.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,ENABLE);//复位SPI1
    
43.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);//停止复位SPI1
    
44. 
    
45.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
46.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    # C: O0 X  `( S7 |# Q
47.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
48.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    
49.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    * S) g4 _' u! ]; t  x
50.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    
51.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
      a1 o! P6 i( E) ^$ e
52.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
53.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    / B" u1 q) L- Z/ T5 r) U
54.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    6 f" m0 s1 E- ^, b7 R* a! D" V
55. 
    4 X& e. z# a% }) U5 q, h; x; |1 q
56.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    4 E! |$ h9 s5 t9 b' D
57. 
    
58. ///        eeprom_read_write_byte(0xff);//启动传输        
    
59. }
    
60. //SPI 速度设置函数
    
61. //SpeedSet:
    ( V8 H8 U1 P% H, O
62. //SPI_BaudRatePrescaler_2   2分频   
    * l3 o* u+ [3 f1 a8 u( c- `
63. //SPI_BaudRatePrescaler_8   8分频   
    
64. //SPI_BaudRatePrescaler_16  16分频  
    
65. //SPI_BaudRatePrescaler_256 256分频
    " H+ C: I5 R7 ^8 b: f- k! f! g" M
66. 
    ) Y* H; N4 Y/ Z
67. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    : H5 g( h: M& \6 r) l
68. {
    * H) N* p$ ~) I/ I9 V* F
69.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    5 d% b! \; i8 _! Q
70.         SPI2->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    
71.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    
72.         SPI_Cmd(SPI2,ENABLE); //使能SPI1
    * A3 H# k* v/ y# E( ]! J
73. 
    
74. }
    ) G$ y) G8 V7 ?* t+ Y
75. 
    ' s- g: S! f. g
76. //SPIx 读写一个字节
    
77. //TxData:要写入的字节
    
78. //返回值:读取到的字节
    ; z* V0 I* y9 _6 ^* ]
79. u8 eeprom_read_write_byte(u8 TxData)
    5 Z" @2 a* E' [; t
80. {               
    7 c) V) y2 {. \& J8 f0 A: I
81.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    . \& ]& c7 K* B1 v2 }/ D7 ?
82. 
    
83.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个byte  数据
    
84. 
    
85.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    : X& w6 {( J4 d7 K, v5 `
86. 
    
87.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                    
    3 Q6 L+ z3 {2 o9 q4 G: M; b; C
88. }
    2 [8 |/ c& D0 \1 t+ h' ?9 {
89. 
    ; c' F% F5 t: g6 l- R: l# a/ y; U
90. //==============================================================================
    
91. // 描述: 在AT25读状态寄存器
    ! m1 H5 l0 D! e0 b% w/ b/ t  {* e9 f6 s
92. // 输入: 无
    / V4 ?5 d& ^7 }) n# K- S. @
93. // 返回: unsigned char dat 状态寄存器数据
    
94. //==============================================================================
    
95. 
    ; e! M8 h9 a" ~- p7 Z7 f+ ^
96. 
    
97. u8 eeprom_read_sr(void)
    
98. {
    
99.         u8 dat;
    : \- s9 q" b. C0 f" f5 X* A* s5 X
100.         eeprom_cs=0;
     $ l7 S% T' b( Z! H
101.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
     
102.         dat = eeprom_read_write_byte(0xff);       //  读回数据
     7 h! v9 z  P3 k7 u5 |9 V9 z
103.         eeprom_cs=1;
     
104.         return  dat;
     5 d, i0 }+ w0 f1 `( k( Y
105. }
     , I/ y0 A# m0 I- t* y
106. 
     . d; [# _+ v7 Q& `9 E2 B
107. //==============================================================================
     
108. // 描述: 向AT25写入一个数据
     1 t1 }: p4 E: e0 a! ^
109. // 输入: unsigned char Dat 字符数据
     
110. //       unsigned int addr 写入的地址
     
111. // 返回: 无
     
112. //==============================================================================
     4 y2 [; u3 W2 V/ {4 @
113. void eeprom_write_byte(u16 addr,u8 Dat)
     
114. {
     
115.         unsigned char Add;
     
116.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     $ m" Q* j+ E- p9 l/ ?
117.         
     ' I4 S- d; E& c3 B' g7 |
118.         eeprom_cs=0;
     : ~6 y0 ~: f1 u9 u1 L, T# v
119.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     6 z% m) {: v5 v
120.         eeprom_cs=1;
     6 C6 S  `# ~2 }) {6 l7 x5 v
121.         
     
122.         eeprom_cs=0;                                  // 芯片使能
     
123.         // 写入写操作指令
     4 [' }5 {% Z5 o
124.         if(addr>0x00ff)
     % X) }5 e" @, F; f) ~
125.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
     # u' _3 X" G4 ]8 ^( A8 d$ A
126.         else
     
127.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
     
128. 
     ) d8 ]: B( o: }2 G9 d3 `! o
129.         // 写入地址
     2 a- \# P) ^$ k
130.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     
131.         eeprom_read_write_byte(Add);
     " a) q4 i8 d5 f  z4 c8 |
132. 
     
133.         // 写入数据
     
134.         eeprom_read_write_byte(Dat);
     ; Z- ~& S# i0 V' m0 O' x$ Z
135.         eeprom_cs=1;                                // 芯片关闭   
     ' w% A0 L5 ~* u/ [8 u$ z2 H' c
136. }
     
137. //==============================================================================
     ; l8 Y# y5 y, O& r, c& j
138. // 描述: 在AT25读一个字节操作
     3 ?* E1 p2 Q/ p) Q# Z, t- o5 Q6 q
139. // 输入: 无
     
140. // 返回: unsigned char dat 读出一个字符数据
     
141. //==============================================================================
     9 C& o3 s5 b$ H9 U+ u
142. u8 eeprom_read_byte(u16 addr)
     3 b( H/ M, M  D# g  E7 W- j6 A% r, v
143. {
     
144.         u8 dat,add;
     
145.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     9 E! O2 |3 H+ ~& L
146.         eeprom_cs=0;
     
147.         // 写入写操作指令
     
148.         if(addr>0x00ff)
     3 L6 `+ I. p- S
149.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     
150.         else
     / R) P1 r& m- ]3 c, e8 P5 J& u- e
151.                 eeprom_read_write_byte(READ);                  // 地址小于255
     . v2 ]5 H1 }6 T2 H# |/ f
152. 
     % J- _8 f( Y; d! l" h/ K
153.         // 写入地址
     4 I( i  ?0 C; ^- ?
154.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     
155.         eeprom_read_write_byte(add);
     $ Z+ R7 W$ {! ]# J' `5 g' O: x- v
156. 
     
157.         // 读出一个数据
     ) c: P3 J( V2 `9 w
158.         dat=eeprom_read_write_byte(0xff);
     5 \4 p2 R4 u/ S9 l4 O; t, A
159.         eeprom_cs=1;
     * Y3 j  J( z9 v  t! C4 f# Q
160.         return dat;
     6 k1 t6 D, Y0 y% N+ Z& |% e, w
161. }
     
162. //==============================================================================
     ; m: B& O, q3 {1 j
163. // 描述: 向AT25连续写入数据
     
164. // 输入: unsigned char *PC 写入数据指针
     
165. //       unsigned int count 写入数量计数  
     
166. //       unsigned int SatAddr 写入起始地址
     
167. // 返回: 无
     ; N$ P5 [( L# x) f8 O8 I! g
168. //==============================================================================
     
169. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
     / s7 i, }& f# @0 ^, |6 a( W
170. {
     
171.         u16 i;
     $ ^  s* y. A$ k  n% k
172.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     
173. 
     0 C' B" |, V' B4 o& L* T4 Y
174.         eeprom_cs=0;
     
175.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     5 @9 |% p! J) k0 D; c
176.         eeprom_cs=1;
     
177.         eeprom_cs=0;
     2 Z4 F' m9 }2 i& |% H: ^
178.         
     , e7 s+ e* V" V# p/ {5 O# z
179.         eeprom_read_write_byte(WRITE);                        // 写入写操作指令
     8 f: |" D1 M/ T, {7 c
180.         eeprom_read_write_byte(startAddr>>8);                 // 写入地址
     
181.         eeprom_read_write_byte(startAddr);
     $ k! |  L5 m+ A, f8 Z
182. 
     5 f3 s4 A/ s3 p* f$ n, Q4 G. A1 I
183.         for(i=0;i<count;i++)// 写入数据
     8 C$ @1 G" ]8 Z/ u6 g0 M  v( Q  z
184.         {
     
185.                 eeprom_read_write_byte(*buf++);
     
186.         }
     2 X# p. @; W# _" F; A
187.         eeprom_cs=1;                                 // 芯片关闭   
     
188. }
     
189. //==============================================================================
     
190. // 描述: 向AT25连续写入n字节的数据
     0 `! r; u( K6 y3 J! k
191. // 输入: unsigned char *PC 写入数据指针
       p( l5 r* X3 m# Z1 d
192. //       unsigned int count 写入数量计数  
     
193. //       unsigned int SatAddr 写入起始地址
     ! C. U3 ~; l0 K& f. H/ k5 m: t
194. // 返回: 无
     
195. //==============================================================================
     & ^1 u  I; i" d3 [+ \) J; M, c
196. void eeprom_write_nbyte(u16 startAddr,u8 *buf,u16 count)
     ' X8 K5 Q* t- {" L% U4 T: o
197. {
     
198.         u16 pageTotal=count/64;
     
199.         u16 pageResidue=count%64;
     & t8 B* \8 C4 U6 }# o
200.         u16 i;
     
201.         u16 pageCnt=0;
     
202.         
     . c4 ^4 R+ G* Y) J4 O8 C
203.         for(i=0;i<pageTotal;i++)
     ; O4 L/ x4 C1 u9 a' e; K- k
204.         {
     . q# Q. N  Y8 C: _5 I; h" r/ y
205.                 eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],64);
     
206.                 pageCnt+=64;
     
207.         }
     
208.         eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],pageResidue); //写入剩余的
     
209. }
     " c  b. p$ r' o
210. 
     + J0 i+ C7 m4 t# M  b
211. 
     / M6 m+ f$ o, D) N& H
212. //==============================================================================
     
213. // 描述: 在AT25连续读数据
     
214. // 输入: unsigned char *PC 读出数据指针
     
215. //       unsigned int count 读出数量计数  
     
216. //       unsigned int SatAddr 读出起始地址
     
217. // 返回: 无
     7 G2 ]! B1 K! J# t$ A! B
218. //==============================================================================
     
219. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     
220. {
     0 }: I6 e6 A% L- N: v: D7 b
221.         unsigned int i;
     - p# P4 n, Q' e) |' ?! a! Q
222.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
223.         eeprom_cs=0;
     6 C2 j% q* r0 L
224.         
     
225.         eeprom_read_write_byte(READ);       // 写入读操作指令           
     
226.         // 写入地址
     
227.         eeprom_read_write_byte(startAddr>>8);
     * ~  t- w% r: T. ?
228.         eeprom_read_write_byte(startAddr);
     7 E9 N) z) q  e5 X8 \. s  n& b
229. 
     + t6 e% O7 v5 m5 `# w! e
230.         // 读出n个数据
     
231.         for(i=0;i<count;i++)
     * c8 J" N$ ^3 M4 V6 E4 |- G' W
232.         {
     
233.                 *buf++ = eeprom_read_write_byte(0xff);
     
234.         }
     9 L0 c  Q5 W7 M3 D% u: o$ w) q( H% N
235.         eeprom_cs=1;
     1 ^' d, o% b6 x
236. }
     - D0 }1 t& q% K; ^5 ]5 h6 f) R+ |
237. 
     
238. 
     . o1 p7 Y  N' Q5 }( j. G

复制代码

- B0 j" P+ l; w2 t  l  o# R7 l$ L