Abbiamo già parlato delle memorie flash interne per le schede rp2040 e gli altri microcontrollori, molto utili per archiviare pagine o file statici. Tuttavia, non adatte per la registrazione dei logs o applicazioni simili, quindi impareremo come collegare e utilizzare una scheda SD che può avere molto spazio, con fattore di forma molto piccolo e con consumi ridotti.
Raspberry Pi Pico W rp2040 how to use SD card
La scheda SD ha un’interfaccia host nativa oltre alla modalità SPI per la comunicazione con i dispositivi master. L’interfaccia nativa utilizza quattro linee per il trasferimento dei dati, in cui il microcontrollore dispone di un modulo controller della scheda SD e necessita di una licenza separata per utilizzarlo. Poiché lo SPI è un protocollo ampiamente utilizzato ed è disponibile nella maggior parte dei microcontrollori a basso costo, la modalità SPI è l’interfaccia ampiamente utilizzata nei sistemi embedded a basso costo. L’intervallo di tensione di lavoro delle SD è compreso tra 2,7 V e 3,6 V, e questo è indicato nel registro delle condizioni operative (OCR). Esiste una scheda SD a basso consumo che funziona a 1.8V ma non è così utilizzata.
Esistono vari fattori di forma, ma la piedinatura di base è la stessa.
MMC SD miniSD microSD pins and size factor
Pin Number Pin Name In SD Mode In SPI Mode 1 DAT2/X Connector Data line 2 No use 2 DAT3/CS Connector Data line 3 Chip Select 3 CMD/DI Command / Response Line Data Input 4 VDD/VDD Power supply (+3.3V) Power supply (+3.3V) 5 CLK/SCLK Clock Serial Clock 6 VSS/VSS Ground Ground 7 DAT0/D0 Connector Data line 0 Data Out 8 DAT1/X Connector Data line 1 No use
Ora interfacciamo la scheda SD.
SD pinout
Raspberry Pi Pico rp2040 pinout low resolution
La tensione di funzionamento ci obbliga a realizzare 2 schemi di connessione distinti in base al tipo nm di microcontrollore. Per interfacciare la scheda SD, utilizzo un adattatore SD con micro SD, il che risulta.
Vista frontale dei pins dell’adattatore SD
SD adapter pins back
Qui il semplice schema di cablaggio sulla SPI primaria.
Raspberry Pi Pico rp2040 SD Card SPI
SD Card Raspberry Pi Pico (SPI) CS GPIO17 SCK GPIO18 MISO GPIO16 MOSI GPIO19 GND GND 3.3v 3.3v
E qui con l’interfaccia SPI secondaria SPI1
Raspberry Pi Pico rp2040 SD Card on secondary SPI1
SD Card Raspberry Pi Pico (SPI1) CS GPIO13 SCK GPIO14 MISO GPIO12 MOSI GPIO15 GND GND 3.3v 3.3v
Vari moduli interfacciano il tuo microcontrollore con il tuo dispositivo e funzionano esattamente come lo schema di connessione Arduino per l’adattatore 5v e lo schema di connessione esp8266 per 3.3v. Quando ne acquisti uno, devi prestare attenzione alla tensione di lavoro.
Esiste qualche variante che supporta 3.3v e 5v, come quella linkata qui.
Puoi trovare il modulo della scheda SD su AliExpress
Qui il cablaggio con SPI standard
Raspberry Pi Pico rp2040 SD Card module SPI
SD Card Raspberry Pi Pico (SPI) CS GPIO17 SCK GPIO18 MISO GPIO16 MOSI GPIO19 GND GND 3.3v 3.3v
e qui con l’interfaccia SPI secondaria (SPI1).
Raspberry Pi Pico rp2040 SD Card module on secondary SPI1
SD Card Raspberry Pi Pico (SPI1) CS GPIO13 SCK GPIO14 MISO GPIO12 MOSI GPIO15 GND GND 3.3v 3.3v
sd.begin() sd.begin(cspin)
Inizializza la libreria e la scheda SD. Questo avvia l’uso del bus SPI e del pin di selezione del chip, che per impostazione predefinita è il pin SS hardware. Restituisce true in caso di successo; falso in caso di fallimento.
sd.exists(filename)
sd.mkdir(filename)
sd.open(filepath) sd.open(filepath, mode) opzionale ): la modalità in cui aprire il file è predefinita FILE_READ – byte . uno tra FILE_READ: apre il file per la lettura, partendo dall’inizio del file. FILE_WRITE: apre il file in lettura e scrittura, partendo dalla fine del file. Restituisce un oggetto File riferito al file aperto; se il file non può essere aperto, questo oggetto risulterà falso in un contesto booleano, cioè puoi testare il valore restituito con “if (f)”.
sd.remove(filename)
rs.rmdir(filename)
file.name()
file.available()
file.close()
file.flush()
file.peek()
file.position() unsigned long ).
file.print(data) file.print(data, base)
file.println() file.println(data) file.println(data, base)
file.seek(pos) unsigned long ). Restituisce true in caso di successo, false in caso di fallimento (boolean )
file.size() unsigned long ).
file .read() file.read(buf, len)
file .write(data) file .write(buf, len)
file.isDirectory()
file.openNextFile()
file.rewindDirectory()
SD.begin(uint8_t csPin, SPISettings cfg = SPI_HALF_SPEED)
SDFS.format()
SDFS .open(path, mode)
SDFS .exists(path)
SDFS .openDir(path)
SDFS .remove(path)
SDFS .rename(pathFrom, pathTo)
SDFS .info(fs_info)
file.getCreationTime()
file.getLastWrite()
Raspberry Pi Pico, W and rp2040: SD Card module SPI
Ora alcuni esempi con il cablaggio di default (SPI).
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
#include <SPI.h>
#include <SD.h>
void printDirectory(File dir, int numTabs);
void setup() {
Serial.begin(9600);
while (!Serial) {
;
}
Serial.print("\nInitializing SD card...");
if (!SD.begin(SS)) {
Serial.println("initialization failed. Things to check:");
Serial.println("* is a card inserted?");
Serial.println("* is your wiring correct?");
Serial.println("* did you change the chipSelect pin to match your shield or module?");
while (1);
} else {
Serial.println("Wiring is correct and a card is present.");
}
Serial.println();
Serial.print("Card type: ");
switch (SD.type()) {
case 0:
Serial.println("SD1");
break;
case 1:
Serial.println("SD2");
break;
case 3:
Serial.println("SDHC/SDXC");
break;
default:
Serial.println("Unknown");
}
Serial.print("Cluster size: ");
Serial.println(SD.clusterSize());
Serial.print("Blocks x Cluster: ");
Serial.println(SD.blocksPerCluster());
Serial.print("Blocks size: ");
Serial.println(SD.blockSize());
Serial.print("Total Blocks: ");
Serial.println(SD.totalBlocks());
Serial.println();
Serial.print("Total Cluster: ");
Serial.println(SD.totalClusters());
Serial.println();
uint32_t volumesize;
Serial.print("Volume type is: FAT");
Serial.println(SD.fatType(), DEC);
volumesize = SD.totalClusters();
volumesize *= SD.clusterSize();
volumesize /= 1000;
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.print("Card size: ");
Serial.println((float)SD.size()/1000);
FSInfo fs_info;
SDFS.info(fs_info);
Serial.print("Total bytes: ");
Serial.println(fs_info.totalBytes);
Serial.print("Used bytes: ");
Serial.println(fs_info.usedBytes);
File dir = SD.open("/");
printDirectory(dir, 0);
}
void loop(void) {
}
void printDirectory(File dir, int numTabs) {
while (true) {
File entry = dir.openNextFile();
if (! entry) {
break;
}
for (uint8_t i = 0; i < numTabs; i++) {
Serial.print('\t');
}
Serial.print(entry.name());
if (entry.isDirectory()) {
Serial.println("/");
printDirectory(entry, numTabs + 1);
} else {
Serial.print("\t\t");
Serial.print(entry.size(), DEC);
time_t cr = entry.getCreationTime();
time_t lw = entry.getLastWrite();
struct tm * tmstruct = localtime(&cr);
Serial.printf("\tCREATION: %d-%02d-%02d %02d:%02d:%02d", (tmstruct->tm_year) + 1900, (tmstruct->tm_mon) + 1, tmstruct->tm_mday, tmstruct->tm_hour, tmstruct->tm_min, tmstruct->tm_sec);
tmstruct = localtime(&lw);
Serial.printf("\tLAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct->tm_year) + 1900, (tmstruct->tm_mon) + 1, tmstruct->tm_mday, tmstruct->tm_hour, tmstruct->tm_min, tmstruct->tm_sec);
}
entry.close();
}
}
E il risultato sarà
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Initializing SD card...Wiring is correct and a card is present.
Card type: SDHC/SDXC
Cluster size: 32768
Blocks x Cluster: 64
Blocks size: 512
Total Blocks: 7451
Total Cluster: 476864
Volume type is: FAT32
Volume size (Kb): 2740977
Volume size (Mb): 2676
Volume size (Gb): 2.61
Card size: 2740977.75
Total bytes: 2740977664
Used bytes: 163840
System Volume Information/
WPSettings.dat 12 CREATION: 2022-07-07 16:19:38 LAST WRITE: 2022-07-07 16:19:40
IndexerVolumeGuid 76 CREATION: 2022-07-07 16:19:40 LAST WRITE: 2022-07-07 16:19:42
testSD.txt 40 CREATION: 1980-01-01 00:00:02 LAST WRITE: 1980-01-01 00:00:02
Ecco un semplice sketch che scrive e legge un file.
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
#include <SPI.h>
#include <SD.h>
File myFile;
void setup() {
Serial.begin(9600);
while (!Serial) {
;
}
Serial.print("Initializing SD card...");
if (!SD.begin(SS)) {
Serial.println("initialization failed!");
while (1);
}
Serial.println("initialization done.");
myFile = SD.open("test.txt", FILE_WRITE);
if (myFile) {
Serial.print("Writing to test.txt...");
myFile.println("testing 1, 2, 3.");
myFile.close();
Serial.println("done.");
} else {
Serial.println("error opening test.txt");
}
myFile = SD.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() {
}
Ecco l’output seriale.
1
2
3
4
5
Initializing SD card...initialization done.
Writing to test.txt...done.
test.txt:
testing 1, 2, 3.
testing 1, 2, 3.
Schede Raspberry Pi Pico e rp2040: pinout, specifiche e configurazione IDE Arduino Schede Raspberry Pi Pico e rp2040: filesystem LittleFS integrato Scheda Raspberry Pi Pico e rp2040: ethernet w5500 e requests HTTP e HTTPS (SSL) Schede Raspberry Pi Pico e rp2040: WiFiNINA con coprocessore WiFi ESP32 Schede Raspberry Pi Pico e rp2040: come utilizzare una scheda SD Dallas ds18b20
Collegamento dell’EByte E70 ai dispositivi Raspberry Pi Pico (rp2040) ed un semplice sketch di esempio
