分享一个代码模块，网上找的一个STM32的SPI2通讯的FM25CL64历程，我自己结合自己的板子改成SPI1很快成功了。1FM25CL64确实简单，通讯和使用都比W25Q64容易
1 T4 U8 O' K8 u, l  ]* H+ H. g2写之前没有必要擦除 类似EEPROM
  P9 U( n" a+ w, F" W先看我板子原理图

两个存储设备挂在SPI1上，CS脚铁电就是PA4
上代码：
& i2 p. g, t* P

1. #ifndef __FM25CL64_H_
   
2. #define __FM25CL64_H_                            
   
3. #include "sys.h"
   
4. 
   8 u* O5 R; }4 N; \: z' U
5. 
   
6. #define        FM25CL64_CS                 PAout(4)                  //FM25CL64片选
   
7. 
   
8. ////FM25CL64指令定义
   : h/ p8 f8 n& T( K' I) h
9. #define        FM25CL64_WREN                0x06                //使能
   
10. #define        FM25CL64_WRDI                0x04                //失能
    7 ]# t5 t1 }' N( W/ m
11. #define        FM25CL64_RDSR                0x05                //读状态
    8 i' n  X; _& i: [9 m; m' n$ X
12. #define        FM25CL64_WRSR                0x01                //写状态
    8 b9 r# |" s+ L6 j- |$ Y2 G, p
13. #define        FM25CL64_READ                0x03                //读数据
    
14. #define        FM25CL64_WRITE        0x02                //写数据
    
15. 
    
16. void        fm25cl64_init(void);//初始化
    
17. uint8_t        fm25cl64_read_sr(void);//读状态
    , V* \& N. w8 t( S7 s6 ]
18. void fm25cl4_write_sr(uint8_t        sr);//写状态
    
19. void fm25cl64_write_enable(void);//使能
    
20. void fm25cl64_write_disable(void);//失能
    
21. void fm25cl6_read_nbyte(uint8_t        *pbuff,        uint16_t read_addr,        uint16_t read_byte);//连续读取N个字节
    & J, u( L  P0 n  _$ T% W/ v
22. void fm25cl6_write_nbyte(uint8_t *pbuff, uint16_t write_addr, uint16_t write_byte);//连续写入N个字节
    - a( {$ m8 d# `4 q: g3 `
23. uint8_t fm25cl6_read_1byte(uint16_t read_addr);//读取一个字节
    8 [' Y! t- m3 H6 E7 Z; u
24. void fm25cl6_write_1byte(uint16_t write_addr, uint8_t write_data);//写入一个字节
    8 R# U& [7 R- t9 a- X) f" t; x
25. void fm25cl6_clear_data(uint16_t write_addr, uint8_t len);//清除LEN长度数据
    
26. #endif
    
27. 
    
28. 
    ; S- N3 q- I4 D7 ~, I8 `
29. 
    
30. 
    
31. 
    
32. 
    5 Z# X4 K% ^- H' L$ N3 i
33. 
    7 L% A6 d) v, a% }& Q. M
34. 
    ! v1 o4 l! E6 E3 ^
35. 
    

复制代码

- C  J( R, w6 R, K# v
2 u( w% G2 k% U8 ^% E$ f8 |% s

1. #include "fm25cl64.h"
   
2. #include "spi.h"
     }* z% u2 g/ E2 Y# ?) ]+ |
3. 
   
4. 
   
5. 
   
6. 
   
7. 
   
8. /*********************************************************************************************************
   + z) z. g5 A5 `! g: s, R
9. **函数名称:        void        fm25cl64_init(void)
   
10. **函数功能：fm25cl64初始化
    
11. **入口参数:无
    3 l) I; @0 ?( I2 [' j# a
12. **返回值:无
    
13. **注释:
    
14. **********************************************************************************************************/
    0 x" i& |7 a- ^) v9 T
15. void        fm25cl64_init(void)
    
16. {
    % z) d5 O/ {9 k# G5 a( U
17.         GPIO_InitTypeDef GPIO_InitStructure;
    
18. 
    ) z+ U/ [1 E. y" c2 U8 [8 E
19.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE );
    9 G7 v3 ^6 @$ q5 n) J$ P) B3 y- z/ f! I
20. 
    
21.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;  
    
22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
    6 b1 X" h; s, l8 P
23.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
25.         GPIO_SetBits(GPIOA, GPIO_Pin_4);                       
    - J! l1 w7 i* {! k  w
26. 
    
27.         FM25CL64_CS=1;                                //SPI FLASH不选中
    
28.   SPI1_Init();                           //初始化SPI
    # a7 w/ I8 O7 O! b, X* G
29.         SPI1_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
    + v9 k. @" o+ b( l/ R8 v: t. [  O
30. }
    
31. 
    
32. /*********************************************************************************************************
    0 Y' F7 J! W( x5 Z. S( D
33. **函数名称:        fm25cl64_read_sr
    - ?9 k/ ~8 a+ g" w
34. **函数功能：读取fm25cl64状态
    9 H1 g4 T0 g5 X  i8 d
35. **入口参数:无
    2 H4 b$ S" V; V6 Z  c% ]1 T% J: R
36. **返回值:读取到的字节
    7 ~9 ?4 R. G$ O
37. **注释:
    6 `4 l) C& _/ H0 }: s. {
38. **********************************************************************************************************/
    & G6 J) T) ~6 R$ A' L& ~
39. uint8_t        fm25cl64_read_sr(void)
    
40. {
    ( M/ v, H9 c, g9 i6 k
41.                 uint8_t        byte = 0;
    4 j7 l* K% [" E
42.        
      n1 a' H  G) T5 e, c
43.                 FM25CL64_CS        = 0;                                                                                                //片选
    
44.                 SPI1_ReadWriteByte(FM25CL64_RDSR);                //写入读状态命令
    
45.                 byte = SPI1_ReadWriteByte(0xFF);                        //写一个空字节再读数据
    
46.                 FM25CL64_CS        = 1;                                                                                                //取消片选
      d4 Y3 L9 ]& M: Q
47.        
    
48.                 return        byte;                //返回数据
    ' V1 h! ~& L0 q+ u& G0 x' b& V
49. }
    
50. 
    
51. 
    
52. /*********************************************************************************************************
    ; s  x! W5 q) d' d4 f& A
53. **函数名称:        fm25cl64_write_sr
    5 v- ^0 h8 _0 j7 {" b- `7 {
54. **函数功能：写fm25cl64状态
    # k4 ]- ~( k9 H+ n: p- c. b
55. **入口参数:状态数据
    
56. **返回值:无
    ( n7 M; t" S6 C) q) c( m, X
57. **注释:
    
58. **********************************************************************************************************/
    
59. void fm25cl4_write_sr(uint8_t        sr)
    2 T  H1 g9 A0 l& T& P
60. {
    " N3 s8 ~. p# R( W8 g. r7 n' N5 x; K
61.                 FM25CL64_CS        = 0;                //片选
    " R5 \* \. e, c/ n. p$ w; A
62.                 SPI1_ReadWriteByte(FM25CL64_WRSR);//写入写状态命令
    + `* S- f3 s  l$ E
63.                 SPI1_ReadWriteByte(sr);        //写入状态数据
    
64.                 FM25CL64_CS        = 1;                //取消片选
    
65. }
    
66. 
    * r  j9 v6 m, v( q% G
67. 
    / G- C5 }3 |+ L6 \$ s5 J5 ?: b6 E
68. /*********************************************************************************************************
    * z9 G5 W8 F( S( P" G1 I2 [# P( I
69. **函数名称:        fm25cl64_write_enable
    + I  A$ u$ W8 s4 G, z
70. **函数功能：使能FM25CL64
    
71. **入口参数:无
    
72. **返回值:无
    * n" Y1 K  i5 w6 i# w% s
73. **注释:
    - p5 q9 |# ?/ J( A/ O
74. **********************************************************************************************************/
    
75. void fm25cl64_write_enable(void)
    
76. {
    5 l8 I. X: H2 a5 z
77.                 FM25CL64_CS        = 0;//片选
    
78.                 SPI1_ReadWriteByte(FM25CL64_WREN);//写入写使能命令
    
79.                 FM25CL64_CS        =        1;//取消片选
    
80. }
    
81. 
    
82. 
    
83. /*********************************************************************************************************
    
84. **函数名称:        fm25cl64_write_disable
    9 V! k1 H  z% q* o, U3 U
85. **函数功能：失能FM25CL64
    
86. **入口参数:无
    2 C0 |$ w% d0 m8 C
87. **返回值:无
    
88. **注释:
    1 t: t: s3 `0 n+ I( Y3 S
89. **********************************************************************************************************/
    
90. void fm25cl64_write_disable(void)
    3 K* u# c7 i# i1 l6 G, N
91. {
    
92.                 FM25CL64_CS = 0;//片选
    . C6 x0 Z0 n) Y+ \! Q) \
93.                 SPI1_ReadWriteByte(FM25CL64_WRDI);//写入写失能命令
    1 C0 o' h. y+ S8 s8 f8 q
94.                 FM25CL64_CS        = 1;//取消片选
    % v8 X: M3 k+ o
95. }
    % C' S; q7 j1 S0 ]' ], B
96. 
    ! m- r  {7 x1 M9 r6 N
97. 
    
98. /*********************************************************************************************************
    
99. **函数名称:        fm25cl6_read_nbyte
    
100. **函数功能：连续读取N字节数据
     
101. **入口参数:*pbuff，读取数据到指针，，read_addr，读数据首址，，read_byte，读多少字节
     
102. **返回值:无
     
103. **注释:
     
104. **********************************************************************************************************/
     
105. void fm25cl6_read_nbyte(uint8_t        *pbuff,        uint16_t read_addr,        uint16_t read_byte)
     * p0 }9 c- _+ A1 L; E
106. {
     
107.                         uint16_t        i;
     
108.        
     
109.        
     
110.                         FM25CL64_CS        =        0;//片选
     8 Q, ~" p  w8 i- _: V1 n
111.                         SPI1_ReadWriteByte(FM25CL64_READ);//写入读数据命令
     , R4 j, \! \# ]  D( R
112.                         SPI1_ReadWriteByte((uint8_t)((read_addr&0xE0)>>8));//写入高8位址，最大地址13位
     
113.                         SPI1_ReadWriteByte((uint8_t)(read_addr));//写入低8位址，
     
114.                        
     " P8 `: r1 i1 t$ C+ U
115.                         for(i=0;i<read_byte;i++)//连续读取数据
     1 |& }: X  |, F, x
116.                         {
     3 A$ U, F# @5 z3 E+ n
117.                                         pbuff[i] = SPI1_ReadWriteByte(0xFF);
     
118.                         }
     
119.                         FM25CL64_CS        =        1;//取消片选
     
120. 
     3 T( P4 o% Y8 h3 O( K5 w
121.                
     ; F: A* r0 j: U
122. }
     
123. 
     
124. 
     , |! T1 _( o* U' x1 G. S% ]
125. /*********************************************************************************************************
     
126. **函数名称:        fm25cl6_write_nbyte
     + U% P2 C) u% y1 \$ o+ q9 M3 @
127. **函数功能：连续写入N字节数据
     
128. **入口参数:*pbuff，写入的数据指针，，write_addr，写入数据首址，，write_byte写多少字节
     6 a# K) C7 m- T* A+ u* d( o
129. **返回值:无
     " T& R9 k1 _  A3 |8 v, p, U
130. **注释:
     / P! C: W9 [  N( Z: e) o
131. **********************************************************************************************************/
     
132. void fm25cl6_write_nbyte(uint8_t *pbuff, uint16_t write_addr, uint16_t write_byte)
     
133. {
     # l; R6 L$ {8 r1 @# j6 h& d8 u
134.                         uint16_t        i;
     
135. 
     
136.        
     : ]7 Y3 z# J! c+ }5 |5 G. d# Y% N% W: i
137.                         fm25cl64_write_enable();//使能写操作,一定要先使能，取消片选后再写作下面操作
     
138.        
     8 s' d% q, ^* l6 e) w1 t* Q
139.                         FM25CL64_CS        =        0;//片选
     
140.                        
     
141.                         SPI1_ReadWriteByte(FM25CL64_WRITE);//写数据命令
     ! Q+ N& g7 H2 q
142.                         SPI1_ReadWriteByte((uint8_t)((write_addr&0xE0)>>8));//写入高8位址，最大地址13位
     
143.                         SPI1_ReadWriteByte((uint8_t)(write_addr));//写入低8位址，
     
144.        
     * [: X' k4 ?1 O  O) q0 @
145.                         for(i=0;i<write_byte;i++)//连续写入数据
     
146.                         {
     % d& j" H" V" T  Z( t2 c
147.                                         SPI1_ReadWriteByte(pbuff[i]);
     ( \; m% M. q0 j! p/ v% j4 c9 a; K
148.                         }
     ) {( u3 j7 @& g4 ^' N# k
149.                         FM25CL64_CS        =        1;//取消片选
     : }$ Y- N0 S( ]9 c6 Z' d6 d. C# B/ a4 q
150. }
     " Z+ ]4 E2 \9 v$ ]# E
151. 
     
152. 
     3 B, U! D: _) H& U+ j3 ?- X
153. 
     8 O% Q5 N; D4 u$ N! [4 L+ u
154. /*********************************************************************************************************
     
155. **函数名称:        fm25cl6_read_data_1byte
     
156. **函数功能：读1字节数据
     
157. **入口参数:read_addr，读取数据地址
     
158. **返回值:返回读取的数据
       @0 ^8 F! T# R) R: p
159. **注释:
     $ u# m  y0 t  o
160. **********************************************************************************************************/
     
161. uint8_t fm25cl6_read_1byte(uint16_t read_addr)
     
162. {
     2 u! x1 Y/ g/ v; x2 H
163.                         uint8_t        dat;
     2 Y& v" u; q' `3 z; x; s8 g& E
164.        
     - N+ u& l1 w8 C/ q* J
165.                         FM25CL64_CS        =        0;//片选
     & ?2 B1 W; V( S3 }- a: e' u3 W
166.        
     $ n6 i8 L3 k$ i# k
167.                         SPI1_ReadWriteByte(FM25CL64_READ);//写入读数据命令
     ) l, o; D7 X) ?. S+ ~# X$ W) f
168.                         SPI1_ReadWriteByte((uint8_t)((read_addr)>>8));//最大地址13位
     & L, d/ H4 p1 T; T( ~
169.                         SPI1_ReadWriteByte((uint8_t)(read_addr));//
     4 k# k1 k2 f" C# Y6 H
170.        
     
171.                         dat = SPI1_ReadWriteByte(0xFF);//读一字节数据
     
172. 
     
173.                         FM25CL64_CS        =        1;//取消片选
     ) O' O4 B) q7 R0 p: q% f
174. 
     
175.                         return        dat;
     
176. }
     ! j# l0 }6 R& A! o# U3 K2 s: c
177. 
     
178. 
     # [7 X9 q# _0 I: w2 ?
179. /*********************************************************************************************************
     
180. **函数名称:        fm25cl6_read_data_1byte
     4 U& P0 e1 Q+ L* N. \' _2 I
181. **函数功能：写入1字节数据
     
182. **入口参数:write_addr，写入数据地址，，write_data，写入的数据
     
183. **返回值:无
     
184. **注释:
     ' U4 X/ G: @/ p; Q+ {8 w" @
185. **********************************************************************************************************/
     ( f& ]" X( U3 e2 e
186. void fm25cl6_write_1byte(uint16_t write_addr, uint8_t write_data)
     5 H2 a& }" `5 R2 `
187. {
     
188. 
     
189.        
     
190.                         fm25cl64_write_enable();//使能写操作,一定要先使能，取消片选后再写作下面操作
     
191.        
     
192.        
     & Z$ T8 ?* Z4 r
193.                         FM25CL64_CS        =        0;//片选
     
194.        
     
195.                         SPI1_ReadWriteByte(FM25CL64_WRITE);//写数据命令
     , A) G) i3 `0 Q
196.                         SPI1_ReadWriteByte((uint8_t)((write_addr)>>8));//最大地址13位
     
197.                         SPI1_ReadWriteByte((uint8_t)(write_addr));//
     
198.        
     , [5 w& I. H- r) _: ?6 [9 ]$ f
199. 
     ) A9 i  p$ e/ [0 d8 R
200.                         SPI1_ReadWriteByte(write_data);//写一字节数据
     
201. 
     2 p, }& z6 S' Z( |
202.                         FM25CL64_CS        =        1;//取消片选
     - K" b, [# ~! |3 e7 l: X7 [7 E
203. }
     / E, L: r. V; b( H$ ?5 R" a7 M
204. 
     
205. 
     
206. /*********************************************************************************************************
     
207. **函数名称:        fm25cl6_clear_data
     9 |6 v: G2 d% w4 L+ p& l9 O
208. **函数功能：清除指定长度数据
     8 X8 q( |1 q, g
209. **入口参数:write_addr，清除数据地址，，len，清除的数据长度
     & c* j. ^9 Z5 t9 A
210. **返回值:无
     ; @4 P% ^, t8 ~5 ]
211. **注释:
     ) `8 N, S1 C" Z: W
212. **********************************************************************************************************/
     
213. void fm25cl6_clear_data(uint16_t write_addr, uint8_t len)
     1 \/ X/ P- L3 [+ n2 y
214. {
     & T5 E' E% w. t+ j% i  X
215. 
     
216.        
     
217.                         fm25cl64_write_enable();//使能写操作,一定要先使能，取消片选后再写作下面操作
     
218.        
     ! ^/ A* u; N4 X7 ]' z& y
219.        
     - T( x' `1 T: p$ ^
220.                         FM25CL64_CS        =        0;//片选
     # d% B$ H! x- Q1 t! c/ G
221.        
     
222.                         SPI1_ReadWriteByte(FM25CL64_WRITE);//写数据命令
     
223.                         SPI1_ReadWriteByte((uint8_t)((write_addr)>>8));//最大地址13位
     
224.                         SPI1_ReadWriteByte((uint8_t)(write_addr));//
     
225.        
     9 o3 V5 z1 T5 b2 q+ ]
226.                         while(len--)
     + F4 ^- V% q) Z! X+ e* X
227.                         {
     
228.                                 SPI1_ReadWriteByte(0x00);//
     
229.                         }
     7 d* g2 H. f4 p1 }! ~
230.                        
     
231.                         FM25CL64_CS        =        1;//取消片选
     & P  Q9 E0 G6 S# k* r
232. }
     
233. 
     
234. 
     , `1 O% s/ X" f9 a: E; D# c" B
235. 
     
236. 
     
237. 
     ' w! s6 A9 E: `# o* o: P4 R
238. 
     
239. 
     3 S2 K" e4 b9 `% t: y; C: A% _
240. 
     
241. 
     
242. 
     $ ?& a: b9 X5 @8 M3 Q. b+ h
243. 
     + r, \$ e& X+ c# R$ d  s" l

复制代码

其实如果面向接口编程，模块调用SPI的函数SPI1_ReadWriteByte还可以抽象，以备可以切换为SPIX_ReadWriteByte。
# t3 m; g6 V& `2 N
1 ]0 `" W1 z9 |) x- |  ?测试代码
6 R, X* R4 q% i. q/ }+ r% b

1. fm25cl64_init();
   
2.         fm25cl6_write_1byte(0,0xAB);
   
3.         GG=fm25cl6_read_1byte(0);
   
4. //        fm25cl6_clear_data(0,1);
   + c$ }9 S: U2 r9 ^1 \
5.         fm25cl6_write_1byte(0,0xCD);
   8 [/ J: z" e, V8 N' l3 _' j+ `
6.         GG=fm25cl6_read_1byte(0);

复制代码

楼主连驱动代码都附上了，真是很给力！！
1 Z2 C8 g) f% H十多年来一ˊ直在用 24C64 的 FRAM 路过．．．
, b1 G5 T9 x% }/ o) d- d

模拟SPI就行 铁电的应该不难