LGT8F328P 跟 M25P16 SPI Flash Memory

eddiewwm

根據 https://www.instructables.com/id ... e-SPI-Flash-Memory/

1. /*
   
2.     windbond_serial_debug.cpp
   
3.     A simple program for the Arduino IDE to help familiarize you with
   
4.     using WinBond flash memory; can also be used to download the entire
   
5.     contents of a flash chip to a file via a serial port interface.
   
6.    
   
7.     Important bits of the code: the low-level flash functions (which
   
8.     implement the timing diagrams in the datasheet), and a simple
   
9.     serial-port command interface that allows you to talk to your
   
10.     UNO with any generic terminal application (even the command line).
    
11.    
    
12.     Copyright 2014, Peter J. Torelli
    
13. 
    
14.     This program is free software: you can redistribute it and/or modify
    
15.     it under the terms of the GNU General Public License as published by
    
16.     the Free Software Foundation, either version 3 of the License, or
    
17.     (at your option) any later version.
    
18. 
    
19.     This program is distributed in the hope that it will be useful,
    
20.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    
21. 
    
22.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
23.     GNU General Public License for more details.
    
24. 
    
25.     You should have received a copy of the GNU General Public License
    
26.     along with this program.  If not, see <http://www.gnu.org/licenses/>   
    
27. 
    
28. 
    
29. Revisions:
    
30.     rev 2 - 21-SEP-2014.
    
31.     User 'fiaskow' pointed out that driving the WEL instruction after
    
32.     program and erase w/o waiting for the op to finish may be corrupting
    
33.     execution. Removed this code (also not needed b/c the WEL is already
    
34.     cleared after page write or chip erase).
    
35. */
    
36. 
    
37. #include <SPI.h>
    
38. // SS:   pin 10
    
39. // MOSI: pin 11
    
40. // MISO: pin 12
    
41. // SCK:  pin 13
    
42. 
    
43. // WinBond flash commands
    
44. #define WB_WRITE_ENABLE       0x06
    
45. #define WB_WRITE_DISABLE      0x04
    
46. #define WB_CHIP_ERASE         0xc7
    
47. #define WB_READ_STATUS_REG_1  0x05
    
48. #define WB_READ_DATA          0x03
    
49. #define WB_PAGE_PROGRAM       0x02
    
50. #define WB_JEDEC_ID           0x9f
    
51. 
    
52. /*
    
53. * These global variables enable assembly of the user serial
    
54. * input command.
    
55. */
    
56. boolean g_command_ready(false);
    
57. String g_command;
    
58. 
    
59. /*
    
60. * print_page_bytes() is a simple helperf function that formats 256
    
61. * bytes of data into an easier to read grid.
    
62. */
    
63. void print_page_bytes(byte *page_buffer) {
    
64.   char buf[10];
    
65.   for (int i = 0; i < 16; ++i) {
    
66.     for (int j = 0; j < 16; ++j) {
    
67.       sprintf(buf, "%02x", page_buffer[i * 16 + j]);
    
68.       Serial.print(buf);
    
69.     }
    
70.     Serial.println();
    
71.   }
    
72. }
    
73. 
    
74. /*
    
75. ================================================================================
    
76. User Interface Routines
    
77. The functions below map to user commands. They wrap the low-level calls with
    
78. print/debug statements for readability.
    
79. ================================================================================
    
80. */
    
81. 
    
82. /*
    
83. * The JEDEC ID is fairly generic, I use this function to verify the setup
    
84. * is working properly.
    
85. */
    
86. void get_jedec_id(void) {
    
87.   Serial.println("command: get_jedec_id");
    
88.   byte b1, b2, b3;
    
89.   _get_jedec_id(&b1, &b2, &b3);
    
90.   char buf[128];
    
91.   sprintf(buf, "Manufacturer ID: %02xh\nMemory Type: %02xh\nCapacity: %02xh",
    
92.     b1, b2, b3);
    
93.   Serial.println(buf);
    
94.   Serial.println("Ready");
    
95. }
    
96. 
    
97. void chip_erase(void) {
    
98.   Serial.println("command: chip_erase");
    
99.   _chip_erase();
    
100.   Serial.println("Ready");
     
101. }
     
102. 
     
103. void read_page(unsigned int page_number) {
     
104.   char buf[80];
     
105.   sprintf(buf, "command: read_page(%04xh)", page_number);
     
106.   Serial.println(buf);
     
107.   byte page_buffer[256];
     
108.   _read_page(page_number, page_buffer);
     
109.   print_page_bytes(page_buffer);
     
110.   Serial.println("Ready");
     
111. }
     
112. 
     
113. void read_all_pages(void) {
     
114.   Serial.println("command: read_all_pages");
     
115.   byte page_buffer[256];
     
116.   for (int i = 0; i < 4096; ++i) {
     
117.     _read_page(i, page_buffer);
     
118.     print_page_bytes(page_buffer);
     
119.   }
     
120.   Serial.println("Ready");
     
121. }
     
122. 
     
123. void write_byte(word page, byte offset, byte databyte) {
     
124.   char buf[80];
     
125.   sprintf(buf, "command: write_byte(%04xh, %04xh, %02xh)", page, offset, databyte);
     
126.   Serial.println(buf);
     
127.   byte page_data[256];
     
128.   _read_page(page, page_data);
     
129.   page_data[offset] = databyte;
     
130.   _write_page(page, page_data);
     
131.   Serial.println("Ready");
     
132. }
     
133. 
     
134. /*
     
135. ================================================================================
     
136. Low-Level Device Routines
     
137. The functions below perform the lowest-level interactions with the flash device.
     
138. They match the timing diagrams of the datahsheet. They are called by wrapper
     
139. functions which provide a little more feedback to the user. I made them stand-
     
140. alone functions so they can be re-used. Each function corresponds to a flash
     
141. instruction opcode.
     
142. ================================================================================
     
143. */
     
144. 
     
145. /*
     
146. * See the timing diagram in section 9.2.35 of the
     
147. * data sheet, "Read JEDEC ID (9Fh)".
     
148. */
     
149. void _get_jedec_id(byte *b1, byte *b2, byte *b3) {
     
150.   digitalWrite(SS, HIGH);
     
151.   digitalWrite(SS, LOW);
     
152.   SPI.transfer(WB_JEDEC_ID);
     
153.   *b1 = SPI.transfer(0); // manufacturer id
     
154.   *b2 = SPI.transfer(0); // memory type
     
155.   *b3 = SPI.transfer(0); // capacity
     
156.   digitalWrite(SS, HIGH);
     
157.   not_busy();
     
158. }  
     
159. 
     
160. /*
     
161. * See the timing diagram in section 9.2.26 of the
     
162. * data sheet, "Chip Erase (C7h / 06h)". (Note:
     
163. * either opcode works.)
     
164. */
     
165. void _chip_erase(void) {
     
166.   digitalWrite(SS, HIGH);
     
167.   digitalWrite(SS, LOW);  
     
168.   SPI.transfer(WB_WRITE_ENABLE);
     
169.   digitalWrite(SS, HIGH);
     
170.   digitalWrite(SS, LOW);  
     
171.   SPI.transfer(WB_CHIP_ERASE);
     
172.   digitalWrite(SS, HIGH);
     
173.   /* See notes on rev 2
     
174.   digitalWrite(SS, LOW);  
     
175.   SPI.transfer(WB_WRITE_DISABLE);
     
176.   digitalWrite(SS, HIGH);
     
177.   */
     
178.   not_busy();
     
179. }
     
180. 
     
181. /*
     
182. * See the timing diagram in section 9.2.10 of the
     
183. * data sheet, "Read Data (03h)".
     
184. */
     
185. void _read_page(word page_number, byte *page_buffer) {
     
186.   digitalWrite(SS, HIGH);
     
187.   digitalWrite(SS, LOW);
     
188.   SPI.transfer(WB_READ_DATA);
     
189.   // Construct the 24-bit address from the 16-bit page
     
190.   // number and 0x00, since we will read 256 bytes (one
     
191.   // page).
     
192.   SPI.transfer((page_number >> 8) & 0xFF);
     
193.   SPI.transfer((page_number >> 0) & 0xFF);
     
194.   SPI.transfer(0);
     
195.   for (int i = 0; i < 256; ++i) {
     
196.     page_buffer[i] = SPI.transfer(0);
     
197.   }
     
198.   digitalWrite(SS, HIGH);
     
199.   not_busy();
     
200. }
     
201. 
     
202. /*
     
203. * See the timing diagram in section 9.2.21 of the
     
204. * data sheet, "Page Program (02h)".
     
205. */
     
206. void _write_page(word page_number, byte *page_buffer) {
     
207.   digitalWrite(SS, HIGH);
     
208.   digitalWrite(SS, LOW);  
     
209.   SPI.transfer(WB_WRITE_ENABLE);
     
210.   digitalWrite(SS, HIGH);
     
211.   digitalWrite(SS, LOW);  
     
212.   SPI.transfer(WB_PAGE_PROGRAM);
     
213.   SPI.transfer((page_number >>  8) & 0xFF);
     
214.   SPI.transfer((page_number >>  0) & 0xFF);
     
215.   SPI.transfer(0);
     
216.   for (int i = 0; i < 256; ++i) {
     
217.     SPI.transfer(page_buffer[i]);
     
218.   }
     
219.   digitalWrite(SS, HIGH);
     
220.   /* See notes on rev 2
     
221.   digitalWrite(SS, LOW);  
     
222.   SPI.transfer(WB_WRITE_DISABLE);
     
223.   digitalWrite(SS, HIGH);
     
224.   */
     
225.   not_busy();
     
226. }
     
227. 
     
228. /*
     
229. * not_busy() polls the status bit of the device until it
     
230. * completes the current operation. Most operations finish
     
231. * in a few hundred microseconds or less, but chip erase
     
232. * may take 500+ms. Finish all operations with this poll.
     
233. *
     
234. * See section 9.2.8 of the datasheet
     
235. */
     
236. void not_busy(void) {
     
237.   digitalWrite(SS, HIGH);  
     
238.   digitalWrite(SS, LOW);
     
239.   SPI.transfer(WB_READ_STATUS_REG_1);      
     
240.   while (SPI.transfer(0) & 1) {};
     
241.   digitalWrite(SS, HIGH);  
     
242. }
     
243. 
     
244. /*
     
245. * This handy built-in callback function alerts the UNO
     
246. * whenever a serial event occurs. In our case, we check
     
247. * for available input data and concatenate a command
     
248. * string, setting a boolean used by the loop() routine
     
249. * as a dispatch trigger.
     
250. */
     
251. void serialEvent() {
     
252.   char c;
     
253.   while (Serial.available()) {
     
254.     c = (char)Serial.read();
     
255.     if (c == ';') {
     
256.       g_command_ready = true;
     
257.     }
     
258.     else {
     
259.       g_command += c;
     
260.     }   
     
261.   }
     
262. }
     
263. 
     
264. void setup(void) {
     
265.   SPI.begin();
     
266.   SPI.setDataMode(0);
     
267.   SPI.setBitOrder(MSBFIRST);
     
268.   Serial.begin(9600);
     
269.   Serial.println("");
     
270.   Serial.println("Ready");
     
271. }
     
272. 
     
273. /*
     
274. * loop() dispatches the commands compiled by the serialEvent
     
275. * parser callback. Some commands take multiple arguments, so
     
276. * I have to split up the strings with some messy manipulation.
     
277. */
     
278. void loop(void) {
     
279.   if (g_command_ready) {
     
280.     if (g_command == "get_jedec_id") {
     
281.       get_jedec_id();
     
282.     }
     
283.     else if (g_command == "chip_erase") {
     
284.       chip_erase();
     
285.     }
     
286.     else if (g_command == "read_all_pages") {
     
287.       read_all_pages();
     
288.     }
     
289.     // A one-parameter command...
     
290.     else if (g_command.startsWith("read_page")) {
     
291.       int pos = g_command.indexOf(" ");
     
292.       if (pos == -1) {
     
293.         Serial.println("Error: Command 'read_page' expects an int operand");
     
294.       } else {
     
295.         word page = (word)g_command.substring(pos).toInt();
     
296.         read_page(page);
     
297.       }
     
298.     }
     
299.     // A three-parameter command..
     
300.     else if (g_command.startsWith("write_byte")) {
     
301.       word pageno;
     
302.       byte offset;
     
303.       byte data;
     
304.       
     
305.       String args[3];
     
306.       for (int i = 0; i < 3; ++i) {
     
307.         int pos = g_command.indexOf(" ");
     
308.         if (pos == -1) {
     
309.           Serial.println("Syntax error in write_byte");
     
310.           goto done;
     
311.         }
     
312.         args[i] = g_command.substring(pos + 1);
     
313.         g_command = args[i];
     
314.       }
     
315.       pageno = (word)args[0].toInt();
     
316.       offset = (byte)args[1].toInt();
     
317.       data = (byte)args[2].toInt();
     
318.       write_byte(pageno, offset, data);
     
319.     }
     
320.     else {
     
321.       Serial.print("Invalid command sent: ");
     
322.       Serial.println(g_command);
     
323.     }
     
324. done:
     
325.     g_command = "";
     
326.     g_command_ready = false;
     
327.   }
     
328. }
     

复制代码