1. #include "eeprom.h"
   
2. 
   1 m; c6 Y1 I4 @. \
3. 
   
4. void eeprom_init()
   
5. {
   8 ^" g6 a0 d1 L4 X: S: H5 G
6.         GPIO_InitTypeDef  GPIO_InitStructure;
   # s9 J4 |* T/ U5 w5 s2 _
7.         SPI_InitTypeDef  SPI_InitStructure;
   2 H% `* m3 b* e
8. 
   
9.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOE, ENABLE);//使能GPIOB时钟
   1 _  G6 D- p" D; j$ T1 d# m- T# [
10.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);//使能SPI1时钟
    ! Y6 P* P- A  x/ k% f6 u
11. 
    $ Q2 ]; ^; r1 ~( ^5 f
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;//复用功能
    
15.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
17.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
18.         GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
    
19.         
    2 I1 N& t9 D& o3 D
20.         //GPIOFB3,4,5初始化设置
    7 T; b9 A1 _  ]6 T0 k2 v% B
21.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PB3~5复用功能输出        
    # g  z& l  V/ C4 }" n7 Q
22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    1 {) [$ R/ g# u6 k% v  r
23.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    % ?& R# l) u4 D( O  O
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
25.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
26.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化        
    " p. j( z" O" B& j$ U
27.         
    
28.         //GPIOFB3,4,5初始化设置
    
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;//PB3~5复用功能输出        
    $ n: o6 y) T# X# w) P8 }
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//复用功能
    
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
      j, z! y- U1 \& a4 c
32.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    + o5 _9 z  ]. Z7 N" }; A" B
33.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    / t% I9 y! [6 n( @0 P* \: e
34.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化        
    
35.         GPIO_SetBits(GPIOE,GPIO_Pin_2|GPIO_Pin_3);        
    # U1 f# F" a% e/ G- ?
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. 
    
41.         //这里只针对SPI口初始化
    
42.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,ENABLE);//复位SPI1
    
43.         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);//停止复位SPI1
    % {7 T8 e  ^, @7 G! J  i( W
44. 
    
45.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
46.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    2 S, Q5 O8 g* q% o8 l, G
47.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
48.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    # C+ ~" n- _& h# B
49.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    6 o4 }7 @  J) j) H6 f2 M5 Q' ]
50.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    8 s9 V2 M7 C0 u1 P; p7 r  G
51.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
52.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    / v! q5 C4 J0 ~# E
53.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
54.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    : A  W8 S/ |& h; W- I$ \0 d
55. 
    
56.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    
57. 
    ! G9 q, @$ Z) H$ W! Y9 Y" O
58. ///        eeprom_read_write_byte(0xff);//启动传输        
    
59. }
    9 A; `' @  [& h. ]8 u! ]9 E
60. //SPI 速度设置函数
    
61. //SpeedSet:
    
62. //SPI_BaudRatePrescaler_2   2分频   
    3 H4 k) C% w4 X" ^! b/ a+ O1 x
63. //SPI_BaudRatePrescaler_8   8分频   
    9 N$ v3 h$ ~8 Y
64. //SPI_BaudRatePrescaler_16  16分频  
    ; \6 B9 R% Z3 j& x0 v' }
65. //SPI_BaudRatePrescaler_256 256分频
    
66. 
      o4 d& \, o8 c
67. void eeprom_set_speed(u8 SPI_BaudRatePrescaler)
    0 U' L4 n3 W# `# T  y
68. {
    
69.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    
70.         SPI2->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    5 e" D8 c  }! d# b/ v! v1 ~7 }8 ~% a
71.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    ! P0 s5 P2 ]' z7 B" @- r" }
72.         SPI_Cmd(SPI2,ENABLE); //使能SPI1
    
73. 
    
74. }
    : q+ `6 |8 l5 G3 |3 Y2 k
75. 
    2 m& h4 s0 A8 ?  k/ A& Y+ U
76. //SPIx 读写一个字节
    : |2 h* |( B% ]# J
77. //TxData:要写入的字节
    
78. //返回值:读取到的字节
    + o6 T& q' S4 C) x! z! B- A
79. u8 eeprom_read_write_byte(u8 TxData)
    : a7 n5 h6 @4 k+ b* i
80. {               
    $ P1 U- z+ X* _
81.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    
82. 
    
83.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个byte  数据
    ) F* _/ \* J/ }0 `. X
84. 
    ' F' Z* X' Z/ M! Y/ g
85.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    
86. 
    
87.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                    
    
88. }
    
89. 
    
90. //==============================================================================
      `1 L4 g; h9 g' A8 T9 x
91. // 描述: 在AT25读状态寄存器
    
92. // 输入: 无
    
93. // 返回: unsigned char dat 状态寄存器数据
    
94. //==============================================================================
    
95. 
    " j9 G2 K% |) y5 c
96. 
    & \8 K& C. l8 Q0 o0 g# i
97. u8 eeprom_read_sr(void)
    
98. {
    
99.         u8 dat;
      V! y) E# S; j1 e! D- g
100.         eeprom_cs=0;
     6 p  v2 l$ v8 z$ s; {, T5 |
101.         eeprom_read_write_byte(RDSR);        //  定入指令0x05
     
102.         dat = eeprom_read_write_byte(0xff);       //  读回数据
     ! M* q+ p" V2 x- y7 o+ G4 r
103.         eeprom_cs=1;
     
104.         return  dat;
     
105. }
     ( f0 F5 p0 P  K1 |  b5 `
106. 
     ) T1 b% r3 o! x! [* X5 O! [9 D- |- _
107. //==============================================================================
     
108. // 描述: 向AT25写入一个数据
     4 O; L  c) N4 c0 `
109. // 输入: unsigned char Dat 字符数据
     ( p# S7 X* x% m# E5 x& W
110. //       unsigned int addr 写入的地址
     
111. // 返回: 无
     
112. //==============================================================================
     
113. void eeprom_write_byte(u16 addr,u8 Dat)
     0 u5 _! j$ m; R, G2 U# {2 Q
114. {
     
115.         unsigned char Add;
     
116.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     * @* x2 ^) n8 d; H( H
117.         
     
118.         eeprom_cs=0;
     
119.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     ' U5 z4 Q# i+ X
120.         eeprom_cs=1;
     : ?$ i, l. C8 k0 y  z& `2 |9 N
121.         
     
122.         eeprom_cs=0;                                  // 芯片使能
     # ~8 I& K$ T; w5 Z. G* b! a1 N& i
123.         // 写入写操作指令
     
124.         if(addr>0x00ff)
     ( a9 y5 s8 o! N
125.                 eeprom_read_write_byte((WRITE|0x08));           // 地址大于255
     
126.         else
     
127.                 eeprom_read_write_byte(WRITE);                  // 地址小于255
     
128. 
     
129.         // 写入地址
     
130.         Add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     ) s( ^% Y) N4 W# x' P# Y
131.         eeprom_read_write_byte(Add);
     7 _1 Y5 s# Y/ r2 n# q3 K( X# p
132. 
     
133.         // 写入数据
     
134.         eeprom_read_write_byte(Dat);
     
135.         eeprom_cs=1;                                // 芯片关闭   
     
136. }
       b. p' f" J: M- ?! T  s  T
137. //==============================================================================
     ( G; S4 |  B  G9 n8 ^5 N
138. // 描述: 在AT25读一个字节操作
     
139. // 输入: 无
     3 o. z+ S5 G. C# `' E3 M
140. // 返回: unsigned char dat 读出一个字符数据
     ) B- q$ X1 j" }9 u* X
141. //==============================================================================
     ' j% X0 D6 i* [; U5 {
142. u8 eeprom_read_byte(u16 addr)
     
143. {
     ) ]( S/ T% O( C  O1 D* e
144.         u8 dat,add;
     . y! @' l2 }) q2 P: Y
145.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     
146.         eeprom_cs=0;
     
147.         // 写入写操作指令
     
148.         if(addr>0x00ff)
     
149.                 eeprom_read_write_byte((READ | 0x08));         // 地址大于255
     3 c& S+ t+ \- C% ^# Q+ ]3 f2 O* o
150.         else
     4 `- Y) M# ?; Z5 E+ z" Q0 j
151.                 eeprom_read_write_byte(READ);                  // 地址小于255
     
152. 
     
153.         // 写入地址
     ! U7 V+ C# r  }+ U6 J
154.         add = (unsigned char)(addr & 0xff);             // 将地址换成8位
     0 \2 E8 G9 w9 N" u: W
155.         eeprom_read_write_byte(add);
     ' ^5 L5 N2 w0 }
156. 
     
157.         // 读出一个数据
     
158.         dat=eeprom_read_write_byte(0xff);
     - y9 ~# l* u  a" T
159.         eeprom_cs=1;
     % f! K7 [1 }1 z* p9 |
160.         return dat;
     
161. }
     
162. //==============================================================================
     
163. // 描述: 向AT25连续写入数据
     % s8 E+ Y" P/ o2 m  o) o( v
164. // 输入: unsigned char *PC 写入数据指针
     
165. //       unsigned int count 写入数量计数  
     
166. //       unsigned int SatAddr 写入起始地址
       v% g/ S% {  l) O# v! o% e. b* G
167. // 返回: 无
     " c1 v1 M. R4 d4 y
168. //==============================================================================
     8 u! D7 ^( V2 L; f& H0 S4 }
169. void eeprom_write_buf(u16 startAddr,u8 *buf,u16 count)
     
170. {
     . `7 e! J, _' m4 q' Z0 t4 y2 b
171.         u16 i;
     
172.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器
     9 \/ _: I2 g4 V( Q* z
173. 
     
174.         eeprom_cs=0;
     
175.         eeprom_read_write_byte(WREN);                           // 写使能锁存
     
176.         eeprom_cs=1;
     
177.         eeprom_cs=0;
     
178.         
     
179.         eeprom_read_write_byte(WRITE);                        // 写入写操作指令
     
180.         eeprom_read_write_byte(startAddr>>8);                 // 写入地址
     
181.         eeprom_read_write_byte(startAddr);
     
182. 
     
183.         for(i=0;i<count;i++)// 写入数据
     2 N) H. n8 ~. p& ~& t
184.         {
     
185.                 eeprom_read_write_byte(*buf++);
     9 d7 ]( \) k& y' |5 P; |  K4 Y
186.         }
     
187.         eeprom_cs=1;                                 // 芯片关闭   
     
188. }
     
189. //==============================================================================
     
190. // 描述: 向AT25连续写入n字节的数据
     
191. // 输入: unsigned char *PC 写入数据指针
     
192. //       unsigned int count 写入数量计数  
     # u# n4 j$ u' ^7 E. {$ a
193. //       unsigned int SatAddr 写入起始地址
     
194. // 返回: 无
     
195. //==============================================================================
     
196. void eeprom_write_nbyte(u16 startAddr,u8 *buf,u16 count)
     9 X4 `4 N' ~1 a# O! }! J
197. {
     7 b2 \) ^: }$ B8 Z) W/ d
198.         u16 pageTotal=count/64;
     
199.         u16 pageResidue=count%64;
     
200.         u16 i;
     
201.         u16 pageCnt=0;
     $ G( }5 l7 a1 O: J
202.         
     
203.         for(i=0;i<pageTotal;i++)
     
204.         {
     ' w! J8 M6 B2 M$ @6 v
205.                 eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],64);
     # f+ w  \; _" W5 T: H+ W
206.                 pageCnt+=64;
     
207.         }
     $ g1 N' h( h% B: P/ w  P# {" U$ R
208.         eeprom_write_buf(startAddr+pageCnt,&buf[pageCnt],pageResidue); //写入剩余的
     
209. }
     / R# z% K( Y; T+ K1 B' P
210. 
     : [) _1 z. B* s* g$ a, ]
211. 
     9 a# z2 d6 k6 n' E' M0 A
212. //==============================================================================
     
213. // 描述: 在AT25连续读数据
     
214. // 输入: unsigned char *PC 读出数据指针
     
215. //       unsigned int count 读出数量计数  
     . _0 Z: v  B4 X
216. //       unsigned int SatAddr 读出起始地址
     
217. // 返回: 无
     . t5 r0 U4 F5 `+ d* y/ X. r
218. //==============================================================================
     
219. void eeprom_read_buf(u16 startAddr,u8 *buf,u16 count)
     
220. {
     
221.         unsigned int i;
     : {- n) G; l0 f4 n
222.         while(eeprom_read_sr()&RDY);                   // 读状态寄存器  
     ! w+ N! A2 q! L5 P% e
223.         eeprom_cs=0;
     
224.         
     4 _9 a4 b. F  q" w4 r, O
225.         eeprom_read_write_byte(READ);       // 写入读操作指令           
     
226.         // 写入地址
     ( n7 j+ m5 {: d0 M* D% A+ k3 v
227.         eeprom_read_write_byte(startAddr>>8);
     ' {9 }5 u# F$ u& @! b+ H3 A; u
228.         eeprom_read_write_byte(startAddr);
     
229. 
     1 ?& h8 l7 Y9 U9 a& U  z1 j! X
230.         // 读出n个数据
     
231.         for(i=0;i<count;i++)
     
232.         {
     
233.                 *buf++ = eeprom_read_write_byte(0xff);
     + H( `/ J# v1 c/ b( m3 j$ _/ i
234.         }
     
235.         eeprom_cs=1;
     % S7 i- U" u5 o' y& N
236. }
     " P2 ~4 v' P+ I  ^% k0 [: f
237. 
     
238. 
     

复制代码

5 P' X& l- @2 G6 O. _' z