Early SMT32 prototype boards did not have built-in SPI flash, but the latest ones, like the WeAct STM32F4 board, have a footprint to add it. And I find this option very useful, the only problem is that the Arduino Core doesn’t have a native library, so we’re going to use the Adafruit one.
STM32 SPI Flash memory storage
We already had explained how to manage SD (you can look at SD management on “How to use SD card with stm32 and SdFat library “), and now we’d like to look at alternative storage like external SPI Flash, similar to the EEPROM but with the biggest size. The SPI Flash has a smaller capacity but is small, fast, and has very low power consumption. SD It’s surely the best choice for size and compatibility, but we pay for these features with a good quantity of energy.
Here my selection of STM32 STM32F103C8T6 STM32F401 STM32F411 ST-Link v2 ST-Link v2 official
Today, we will see the SPI Flash memory (NOR Flash); they are a single chip that can be managed via SPI and have high-speed access and low power consumption.
Flash memory is an electronic non-volatile computer memory storage medium that can be electrically erased and reprogrammed. The two main types of flash memory, NOR flash and NAND flash, are named for the NOR and NAND logic gates. NAND flash and NOR flash use the same cell design, consisting of floating gate MOSFETs. They differ at the circuit level: in NAND flash, the relationship between the bit line and the word lines resembles a NAND gate; in NOR flash, it resembles a NOR gate; this depends on whether the state of the bit line or word lines is pulled high or low.
Wikipedia
There are SMD and Discrete IC managed by SPI protocol.
SPI Flash Discrete PDIP pinout
SPI Flash SMD SOIC DIP8 pinout
Here a set of SPI flash with different size w25q16 SMD 2Mb - w25q16 Discrete 2Mb -
w25q32 SMD 4Mb - w25q32 Discrete 4Mb -
w25q64 SMD 8Mb - w25q64 Discrete 8Mb -
w25q128 SMD 16Mb - w25q128 Discrete 16Mb
W25Q32 W25Q64 w25q128 module 4Mb 8Mb 16Mb
We start with the classic STM32F1 blue-pill very common prototype board without SPI Flash footprint.
Pinout STM32 STM32F1 STM32F103 STM32F103C8 low resolution
So you can refer to the pinout and connect pins 8, 9, 10, and 4 for CS.
STM32F1 SPI Flash PA4 /CS Pulled UP if not standard CS PA6 DI (IO1 ) PA7 DI (IO0 ) PA5 CLK 3.3v /WP 3.3v /Hold GND GND 3.3v VCC
STM32 SPI Flash wiring on breadboard
For the capacitor, I use a 0.1μF, and It works correctly, but the standard value was 0.01μF.
STM32 SPI Flash wiring schema
This device has a native footprint to add SPI Flash.
STM32 STM32F401 STM32F401CCU6 pinout low resolution
For this device, we are going to use the default footprint.
STM32F4 SPI Flash PA4 CS PA6 DI (IO1 ) PA7 DI (IO0 ) PA5 CLK 3.3v /WP 3.3v /Hold GND GND 3.3v VCC
For the capacitor, I used a 0.1μF, and It works correctly, but the standard value was 0.01μF.
STM32F4 SPI Flash wiring schema
Here is the footprint before adding the SPI Flash. You can also see the footprint for a capacitor (C15) for the best performance, you must add a 104 0.1uF 0402 cap .
STM32 STM32F4 black pill bottom SPI Flash footprint
You can get more information on the relative article with the pinout and schema .
STM32 STM32F4 black pill with SPI Flash installed
If you don’t need a particular data structures, you can do basic and raw usage of the SPI Flash.
For additional information on this library, you can see the article “Arduino: fast external SPI Flash memory “.
For basic usage, I advise using a library named SPIMemory, which is quite simple but with good support without difficulty. You can download It via the library manager from Arduino IDE.
SPIMemory library from Arduino IDE library manager
Here is a simple example that stores a JSON string in the initial address 0, and I re-read It, then I ask the method getAddress for the first available contiguous position where I can store another JSON string, and I save It and re-read.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include <SPI.h>
#include <SPIMemory.h>
#include <ArduinoJson.h>
SPIFlash flash(SS);
void setup() {
Serial.begin(115200);
while (!Serial) ;
delay(100);
flash.begin();
Serial.print(F("Flash size: "));
Serial.print((long)(flash.getCapacity()/1000));
Serial.println(F("Kb"));
unsigned long strAddr = 0;
unsigned long strAddrSecondString = 0;
Serial.println();
Serial.println(F("Generate JSON file!"));
DynamicJsonDocument doc(512);
doc["energyLifetime"] = 21698620;
doc["energyYearly"] = 1363005;
Serial.print(F("Put data in a buffer.. "));
String buf;
if (serializeJson(doc, buf) == 0) {
Serial.println(F("failed to write buffer"));
}
if (flash.writeStr(strAddr, buf)){
Serial.print(F("OK, writed on address "));
Serial.println(strAddr);
}else{
Serial.println(F("KO"));
}
String outputString = "";
if (flash.readStr(strAddr, outputString)) {
Serial.print(F("Read json: "));
Serial.println(outputString);
Serial.print(F("From address: "));
Serial.println(strAddr);
}
Serial.println(F("Generate JSON file!"));
DynamicJsonDocument doc2(512);
doc2["energyLifetime"] = 222;
doc2["energyYearly"] = 333;
Serial.println();
Serial.print(F("Check first free sector: "));
strAddrSecondString = flash.getAddress(doc2.size());
Serial.println(strAddrSecondString);
Serial.println();
Serial.print(F("Stream data in flash memory!"));
Serial.print(F("Put data in a buffer.."));
String buf2;
if (serializeJson(doc2, buf2) == 0) {
Serial.println(F("failed to write buffer"));
}
if (flash.writeStr(strAddrSecondString, buf2)){
Serial.print(F("OK, writed on address "));
Serial.println(strAddrSecondString);
}else{
Serial.println(F("KO"));
}
String outputString2 = "";
if (flash.readStr(strAddrSecondString, outputString2)) {
Serial.print(F("Read data: "));
Serial.println(outputString2);
Serial.print(F("From address: "));
Serial.println(strAddrSecondString);
}
while (!flash.eraseSector(strAddr));
while (!flash.eraseSector(strAddrSecondString));
}
void loop() {
}
Here is the console result.
Flash size: 8388Kb
Generate JSON file!
Put data in a buffer.. OK, writed on address 0
Read json: {"energyLifetime":21698620,"energyYearly":1363005}
From address: 0
Generate JSON file!
Check first free sector: 56
Stream data in flash memory!Put data in a buffer..OK, writed on address 56
Read data: {"energyLifetime":222,"energyYearly":333}
From address: 56
A more complex library (and more hungry of resources) It’s the Adafruit one, the Adafruit SPIFlash , that needs to be used with the SdFat Adafruit fork .
You can also find these libraries on library manager “Adafruit SPIFlash” and “SdFat – Adafruit Fork”.
Arduino IDE library manager Adafruit SPIFlash and SdFat fork
The set of chips is supported. It’s limited to a specified list but creates a new device. It’s simple; for example, I have a W25X80AVAIZ (I think Winbond clone), a discrete component buy for a very low price.
1Mb capacity;
104Mhz of speed;
Winbond clone;
Single dual and quad SPI.
Then, I write a simple sketch to check the compatibility:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#include "SdFat.h"
#include "Adafruit_SPIFlash.h"
Adafruit_FlashTransport_SPI flashTransport(SS, SPI);
Adafruit_SPIFlash flash(&flashTransport);
void setup()
{
Serial.begin(115200);
while ( !Serial ) delay(100);
if (flash.begin()) {
Serial.println(F("Device finded and supported!"));
} else {
Serial.println(F("Problem to discover and configure device, check wiring also!"));
}
flashTransport.setClockSpeed(4000000, 4000000);
Serial.println();
Serial.println("Adafruit Serial Flash get basic info: ");
Serial.print("JEDEC ID (FFFFFF for unknown): "); Serial.println(flash.getJEDECID(), HEX);
Serial.print("Flash size: "); Serial.println(flash.size());
Serial.println();Serial.println();
uint8_t jedec_ids[4];
flashTransport.readCommand(SFLASH_CMD_READ_JEDEC_ID, jedec_ids, 4);
if (jedec_ids[1] == 0x7F) {
jedec_ids[1] = jedec_ids[2];
jedec_ids[2] = jedec_ids[3];
}
Serial.println("Retrieve JDEC_ID");
Serial.print("Manufacturer ID: 0x");
Serial.println(jedec_ids[0], HEX);
Serial.print("Memory Type: 0x");
Serial.println(jedec_ids[1], HEX);
Serial.print("Capacity: 0x");
Serial.println(jedec_ids[2], HEX);
Serial.print("Capacity DEC: ");
Serial.println(jedec_ids[2], DEC);
}
void loop()
{
}
The serial output for my unsupported device is:
1
2
3
4
5
6
7
8
9
10
11
12
13
Unknown flash device 0xEF4014
Problem to discover and configure device, check wiring also!
Adafruit Serial Flash get basic info:
JEDEC ID (FFFFFF for unknown): FFFFFF
Flash size: 0
Retrieve JDEC_ID
Manufacturer ID: 0xEF
Memory Type: 0x40
Capacity: 0x14
Capacity DEC: 20
So I get from the Adafruit_SPIFlash library the file flash_devices.h, and I get the most similar device is in the list.
Then I use:
Capacity DEC to get the size: .total_size = (1UL << 20), /* 1 MiB */.manufacturer_id = 0xef.memory_type = 0x40.capacity = 0x14
I try to find some information on the compatible device datasheet.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#define W25X80BV \
{ \
.total_size = (1UL << 20), \
.start_up_time_us = 5000, .manufacturer_id = 0xef, \
.memory_type = 0x40, .capacity = 0x14, .max_clock_speed_mhz = 104, \
.quad_enable_bit_mask = 0x02, .has_sector_protection = false, \
.supports_fast_read = true, .supports_qspi = true, \
.supports_qspi_writes = true, .write_status_register_split = false, \
.single_status_byte = false, .is_fram = false, \
}
static const SPIFlash_Device_t possible_devices[] = {
W25X80BV,
};
if (!flash.begin(possible_devices)) {
Serial.println("Error, failed to initialize flash chip!");
while(1) yield();
}
Now the complete test sketch become:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include "SdFat.h"
#include "Adafruit_SPIFlash.h"
Adafruit_FlashTransport_SPI flashTransport(SS, SPI);
Adafruit_SPIFlash flash(&flashTransport);
void setup()
{
Serial.begin(115200);
while ( !Serial ) delay(100);
#define W25X80BV \
{ \
.total_size = (1UL << 20), \
.start_up_time_us = 5000, .manufacturer_id = 0xef, \
.memory_type = 0x40, .capacity = 0x14, .max_clock_speed_mhz = 104, \
.quad_enable_bit_mask = 0x02, .has_sector_protection = false, \
.supports_fast_read = true, .supports_qspi = true, \
.supports_qspi_writes = true, .write_status_register_split = false, \
.single_status_byte = false, .is_fram = false, \
}
static const SPIFlash_Device_t possible_devices[] = {
W25X80BV,
};
if (flash.begin(possible_devices)) {
Serial.println(F("Device finded and supported!"));
} else {
Serial.println(F("Problem to discover and configure device, check wiring also!"));
}
flashTransport.setClockSpeed(4000000, 4000000);
Serial.println();
Serial.println("Adafruit Serial Flash get basic info: ");
Serial.print("JEDEC ID (FFFFFF for unknown): "); Serial.println(flash.getJEDECID(), HEX);
Serial.print("Flash size: "); Serial.println(flash.size());
Serial.println();Serial.println();
uint8_t jedec_ids[4];
flashTransport.readCommand(SFLASH_CMD_READ_JEDEC_ID, jedec_ids, 4);
if (jedec_ids[1] == 0x7F) {
jedec_ids[1] = jedec_ids[2];
jedec_ids[2] = jedec_ids[3];
}
Serial.println("Retrieve JDEC_ID");
Serial.print("Manufacturer ID: 0x");
Serial.println(jedec_ids[0], HEX);
Serial.print("Memory Type: 0x");
Serial.println(jedec_ids[1], HEX);
Serial.print("Capacity: 0x");
Serial.println(jedec_ids[2], HEX);
Serial.print("Capacity DEC: ");
Serial.println(jedec_ids[2], DEC);
}
void loop()
{
}
And now the result is:
1
2
3
4
5
6
7
8
9
10
11
12
Device finded and supported!
Adafruit Serial Flash get basic info:
JEDEC ID (FFFFFF for unknown): EF4014
Flash size: 1048576
Retrieve JDEC_ID
Manufacturer ID: 0xEF
Memory Type: 0x40
Capacity: 0x14
Capacity DEC: 20
To check if It’s ok, you can use the test given in the library. First, you must launch the example SdFat_speedtest; for Arduino UNO, like the board with little RAM, you must reduce the buffer from
to
here is the complete sketch with custom IC:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include "SdFat.h"
#include "Adafruit_SPIFlash.h"
#define CUSTOM_CS SS
#define CUSTOM_SPI SPI
#define EXTERNAL_FLASH_USE_QSPI
Adafruit_FlashTransport_SPI flashTransport(CUSTOM_CS, CUSTOM_SPI);
Adafruit_SPIFlash flash(&flashTransport);
#define BUFSIZE 4096
uint8_t bufwrite[BUFSIZE] __attribute__ ((aligned(4)));
uint8_t bufread[BUFSIZE] __attribute__ ((aligned(4)));
void setup()
{
Serial.begin(115200);
while ( !Serial ) delay(100);
#define W25X80BV \
{ \
.total_size = (1UL << 20), \
.start_up_time_us = 5000, .manufacturer_id = 0xef, \
.memory_type = 0x40, .capacity = 0x14, .max_clock_speed_mhz = 104, \
.quad_enable_bit_mask = 0x02, .has_sector_protection = false, \
.supports_fast_read = true, .supports_qspi = true, \
.supports_qspi_writes = true, .write_status_register_split = false, \
.single_status_byte = false, .is_fram = false, \
}
static const SPIFlash_Device_t possible_devices[] = {
W25X80BV,
};
flash.begin();
Serial.println("Adafruit Serial Flash Speed Test example");
Serial.print("JEDEC ID: "); Serial.println(flash.getJEDECID(), HEX);
Serial.print("Flash size: "); Serial.println(flash.size());
Serial.flush();
write_and_compare(0xAA);
write_and_compare(0x55);
Serial.println("Speed test is completed.");
Serial.flush();
}
void print_speed(const char* text, uint32_t count, uint32_t ms)
{
Serial.print(text);
Serial.print(count);
Serial.print(" bytes in ");
Serial.print(ms / 1000.0F, 2);
Serial.println(" seconds.");
Serial.print("Speed : ");
Serial.print( (count / 1000.0F) / (ms / 1000.0F), 2);
Serial.println(" KB/s.\r\n");
}
bool write_and_compare(uint8_t pattern)
{
uint32_t ms;
Serial.println("Erase chip");
Serial.flush();
#define TEST_WHOLE_CHIP
#ifdef TEST_WHOLE_CHIP
uint32_t const flash_sz = flash.size();
flash.eraseChip();
#else
uint32_t const flash_sz = 4096;
flash.eraseSector(0);
#endif
flash.waitUntilReady();
memset(bufwrite, (int) pattern, sizeof(bufwrite));
Serial.printf("Write flash with 0x%02X\n", pattern);
Serial.flush();
ms = millis();
for(uint32_t addr = 0; addr < flash_sz; addr += sizeof(bufwrite))
{
flash.writeBuffer(addr, bufwrite, sizeof(bufwrite));
}
uint32_t ms_write = millis() - ms;
print_speed("Write ", flash_sz, ms_write);
Serial.flush();
Serial.println("Read flash and compare");
Serial.flush();
uint32_t ms_read = 0;
for(uint32_t addr = 0; addr < flash_sz; addr += sizeof(bufread))
{
memset(bufread, 0, sizeof(bufread));
ms = millis();
flash.readBuffer(addr, bufread, sizeof(bufread));
ms_read += millis() - ms;
if ( memcmp(bufwrite, bufread, BUFSIZE) )
{
Serial.printf("Error: flash contents mismatched at address 0x%08X!!!", addr);
for(uint32_t i=0; i<sizeof(bufread); i++)
{
if ( i != 0 ) Serial.print(' ');
if ( (i%16 == 0) )
{
Serial.println();
Serial.printf("%03X: ", i);
}
Serial.printf("%02X", bufread[i]);
}
Serial.println();
return false;
}
}
print_speed("Read ", flash_sz, ms_read);
Serial.flush();
return true;
}
void loop()
{
}
If you have a Serial output like this (I use […] to indicate the line replication):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Adafruit Serial Flash Speed Test example
JEDEC ID: EF4014
Flash size: 1048576
Erase chip
Write flash with 0xAA
Write 1048576 bytes in 1.03 seconds.
Speed : 1016.06 KB/s.
Read flash and compare
Error: flash contents mismatched at address 0x00000000!!!
000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[...]
FF0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Erase chip
Write flash with 0x55
Write 1048576 bytes in 1.03 seconds.
Speed : 1017.05 KB/s.
Read flash and compare
Error: flash contents mismatched at address 0x00000000!!!
000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[...]
FF0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Speed test is completed.
The lines (or other HEX characters) with
1
000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
indicate that the data compared don’t match , so (If the previous test sketch work) probably you had some problem.
In most cases, the SPI speed is too high; this does not mean that the speed is too high for the microcontroller or IC, but it can be a problem with a poor connection cable.
Arduino MKR SAMD is supported very well by this library, so you don’t have to do anything, read more in the next paragraph.
But the solution to this was to reduce the speed, so you must go to add a line like this after the flash.begin():
flashTransport.setClockSpeed(24000000, 24000000);
the command set the SPI speed to 24Mhz, and now the result becomes like so:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Adafruit Serial Flash Speed Test example
JEDEC ID: EF4014
Flash size: 1048576
Erase chip
Write flash with 0xAA
Write 1048576 bytes in 4.07 seconds.
Speed : 257.38 KB/s.
Read flash and compare
Read 1048576 bytes in 0.47 seconds.
Speed : 2226.28 KB/s.
Erase chip
Write flash with 0x55
Write 1048576 bytes in 4.07 seconds.
Speed : 257.38 KB/s.
Read flash and compare
Read 1048576 bytes in 0.47 seconds.
Speed : 2231.01 KB/s.
Speed test is completed.
If no compare errors are shown, the SPI Flash was correctly configured.
SMT32F1 with external SPI Flash on breadboard
First of all, you must Format the SPI Flash; in the examples of Adafruit_SPIFlash, you can find the SdFat_format example
When you launch the sketch, It asks you to insert, in the Serial monitor, “OK” in camel case, here the Serial output result.
1
2
3
4
5
6
7
8
9
10
11
12
13
Adafruit SPI Flash FatFs Format Example
Flash size: 8192 KB
Flash chip JEDEC ID: 0xEF4017
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
This sketch will ERASE ALL DATA on the flash chip and format it with a new filesystem!
Type OK (all caps) and press enter to continue.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
>>Send to COM17: "OK"<<
Creating and formatting FAT filesystem (this takes ~60 seconds)...
Setting disk label to: EXT FLASH
Formatted flash!
Flash chip successfully formatted with new empty filesystem!
Now you are ready to use the SPI Flash with FAT FS.
If you want to use the file-system FAT, I advise using a SPIFlash with more than 1Mb of space.
Here is a simple sketch that creates a test.txt file with the string <num> -> testing 1, 2, 3. 100 times.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include "SdFat.h"
#include "Adafruit_SPIFlash.h"
Adafruit_FlashTransport_SPI flashTransport(SS, SPI);
Adafruit_SPIFlash flash(&flashTransport);
FatFileSystem fatfs;
File myFile;
void setup()
{
Serial.begin(115200);
while ( !Serial ) delay(100);
if (flash.begin()) {
Serial.println(F("Device finded and supported!"));
} else {
Serial.println(F("Problem to discover and configure device, check wiring also!"));
}
Serial.println("Adafruit Serial Flash read write example");
Serial.print("JEDEC ID: "); Serial.println(flash.getJEDECID(), HEX);
Serial.print("Flash size: "); Serial.println(flash.size());
Serial.flush();
Serial.println();
if (!fatfs.begin(&flash)) {
Serial.println("Error, failed to mount newly formatted filesystem!");
Serial.println("Was the flash chip formatted with the SdFat_format example?");
while(1) yield();
}
Serial.println("Mounted filesystem!");
Serial.println();
myFile = fatfs.open("test.txt", FILE_WRITE);
if (myFile) {
Serial.print("Writing to test.txt...");
for (int i=0;i<100;i++){
myFile.print(i);
myFile.println(" -> testing 1, 2, 3.");
}
myFile.close();
Serial.println("done.");
} else {
Serial.println("error opening test.txt");
}
myFile = fatfs.open("test.txt");
if (myFile) {
Serial.println("test.txt:");
while (myFile.available()) {
Serial.write(myFile.read());
}
myFile.close();
} else {
Serial.println("error opening test.txt");
}
}
void loop() {
}
The result becomes like so:
1
2
3
4
5
6
7
8
9
10
11
12
13
Device finded and supported!
Adafruit Serial Flash Speed Test example
JEDEC ID: EF4017
Flash size: 8388608
Mounted filesystem!
Writing to test.txt...done.
test.txt:
0 -> testing 1, 2, 3.
[...]
99 -> testing 1, 2, 3.
ets Jun 8 2016 00:22:57
Now we can call some command to retrieve the filesystem info and then get the list of files with the ls command.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include "SdFat.h"
#include "Adafruit_SPIFlash.h"
Adafruit_FlashTransport_SPI flashTransport(SS, SPI);
Adafruit_SPIFlash flash(&flashTransport);
FatFileSystem fatfs;
void setup()
{
Serial.begin(115200);
while ( !Serial ) delay(100);
if (flash.begin()) {
Serial.println(F("Device finded and supported!"));
} else {
Serial.println(F("Problem to discover and configure device, check wiring also!"));
}
Serial.println("Adafruit Serial Flash Speed Test example");
Serial.print("JEDEC ID: "); Serial.println(flash.getJEDECID(), HEX);
Serial.print("Flash size: "); Serial.println(flash.size());
Serial.flush();
if (!fatfs.begin(&flash)) {
Serial.println("Error, failed to mount newly formatted filesystem!");
Serial.println("Was the flash chip formatted with the SdFat_format example?");
while(1) yield();
}
Serial.println("Mounted filesystem!");
Serial.print("Clusters: ");
Serial.println(fatfs.clusterCount());
Serial.print("Blocks x Cluster: ");
Serial.println(fatfs.blocksPerCluster());
Serial.print("Total Blocks: ");
Serial.println(fatfs.blocksPerCluster() * fatfs.clusterCount());
Serial.println();
uint32_t volumesize;
Serial.print("Volume type is: FAT");
Serial.println(fatfs.fatType(), DEC);
volumesize = fatfs.blocksPerCluster();
volumesize *= fatfs.clusterCount();
volumesize /= 2;
Serial.print("Volume size (Kb): ");
Serial.println(volumesize);
Serial.print("Volume size (Mb): ");
volumesize /= 1024;
Serial.println(volumesize);
Serial.print("Volume size (Gb): ");
Serial.println((float)volumesize / 1024.0);
Serial.println("\nFiles found on the card (name, date and size in bytes): ");
fatfs.rootDirStart();
fatfs.ls(LS_R | LS_DATE | LS_SIZE);
}
void loop(void) {
}
The result becomes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Device finded and supported!
Adafruit Serial Flash Speed Test example
JEDEC ID: EF4017
Flash size: 8388608
Mounted filesystem!
Clusters: 2043
Blocks x Cluster: 8
Total Blocks: 16344
Volume type is: FAT12
Volume size (Kb): 8172
Volume size (Mb): 7
Volume size (Gb): 0.01
Files found on the card (name, date and size in bytes):
2000-01-01 01:00:00 0 mischianti/
2000-01-01 01:00:00 65 test.txt
Arduino: fast external SPI Flash memory Arduino MKR SAMD: FAT filesystem on external SPI flash memory esp32 and esp8266: FAT filesystem on external SPI flash memory STM32: SPI flash memory FAT FS
STM32F1 Blue-Pill: pinout, specs, and Arduino IDE configuration (STM32duino and STMicroelectronics) STM32: program (STM32F1) via USB with STM32duino bootloader STM32: programming (STM32F1 STM32F4) via USB with HID boot-loader STM32F4 Black-Pill: pinout, specs, and Arduino IDE configuration STM32: ethernet w5500 with plain HTTP and SSL (HTTPS) STM32: ethernet enc28j60 with plain HTTP and SSL (HTTPS) STM32: WiFiNINA with ESP32 WiFi Co-Processor
STM32F1 Blue-pill: WiFi shield (WiFiNINA) STM32F4 Black-pill: WiFi shield (WiFiNINA)
How to use SD card with stm32 and SdFat library \STM32: SPI flash memory FAT FS STM32: internal RTC, clock, and battery backup (VBAT) STM32 LoRa
Unleashing IoT Potential: Integrating STM32F1 Blue-Pill with EByte LoRa E32, E22, and E220 Shields Unleashing IoT Potential: Integrating STM32F4 Black-Pill with EByte LoRa E32, E22, and E220 Shields
STM32 Power saving
STM32F1 Blue-Pill clock and frequency management STM32F4 Black-Pill clock and frequency management Intro and Arduino vs STM framework Library LowPower, wiring, and Idle (STM Sleep) mode Sleep, deep sleep, shutdown, and power consumption Wake up from RTC alarm and Serial Wake up from the external source Backup domain intro and variable preservation across reset RTC backup register and SRAM preservation
STM32 send emails with attachments and SSL (like Gmail): w5500, enc28j60, SD, and SPI Fash FTP server on STM32 with w5500, enc28j60, SD Card, and SPI Flash Connecting the EByte E70 to STM32 (black/blue pill) devices and a simple sketch example
