WPI304N Scudo di registrazione della scheda microSD per Arduino
Manuale d'uso
Scudo di registrazione della scheda microSD per Arduino®

WPI304N

Introduzione

A tutti i residenti dell'Unione Europea
Informazioni ambientali importanti su questo prodotto
Questo simbolo sul dispositivo o sulla confezione indica che lo smaltimento del dispositivo dopo il suo ciclo di vita potrebbe danneggiare l'ambiente. Non smaltire l'unità (o le batterie) come rifiuti urbani indifferenziati; dovrebbe essere portato in un'azienda specializzata per il riciclaggio. Questo dispositivo deve essere restituito al distributore o a un servizio di riciclaggio locale. Rispettare le norme ambientali locali.
In caso di dubbi, contattare le autorità locali preposte allo smaltimento dei rifiuti.
Grazie per aver scelto Whadda! Leggere attentamente il manuale prima di mettere in servizio questo dispositivo. Se il dispositivo è stato danneggiato durante il trasporto, non installarlo o utilizzarlo e contattare il rivenditore.

Istruzioni di sicurezza

Prima di utilizzare questo apparecchio, leggere e comprendere il presente manuale e tutti i segnali di sicurezza.
Solo per uso interno.

• Questo dispositivo può essere utilizzato da bambini di età pari o superiore a 8 anni e da persone con ridotte capacità fisiche, sensoriali o mentali o prive di esperienza e conoscenza, se sono state supervisionate o hanno ricevuto istruzioni sull'uso sicuro del dispositivo e se ne comprendono i pericoli. I bambini non devono giocare con il dispositivo. La pulizia e la manutenzione da parte dell'utente non devono essere eseguite da bambini senza supervisione.

Linee guida generali

• Fare riferimento alla Garanzia di qualità e assistenza Velleman® riportata nelle ultime pagine del presente manuale.
• Per motivi di sicurezza sono vietate tutte le modifiche del dispositivo. I danni causati dalle modifiche apportate dall'utente al dispositivo non sono coperti dalla garanzia.
• Utilizzare il dispositivo solo per lo scopo previsto. L'utilizzo del dispositivo in modo non autorizzato invaliderà la garanzia.
• I danni causati dalla mancata osservanza di alcune linee guida contenute nel presente manuale non sono coperti dalla garanzia e il rivenditore non si assume alcuna responsabilità per eventuali difetti o problemi derivanti.
• Né Velleman Group nv né i suoi rivenditori possono essere ritenuti responsabili per eventuali danni (straordinari, incidentali o indiretti) di qualsiasi natura (finanziaria, fisica...) derivanti dal possesso, dall'uso o dal guasto di questo prodotto.
• Conservare questo manuale per riferimento futuro.

Che cosa è Arduino®

Arduino ® è una piattaforma di prototipazione open source basata su hardware e software di facile utilizzo. Le schede Arduino ® sono in grado di leggere gli input - sensore di accensione, un dito su un pulsante o un messaggio di Twitter - e trasformarli in un output - l'attivazione di un motore, l'accensione di un LED, la pubblicazione di qualcosa online. Puoi dire alla tua scheda cosa fare inviando una serie di istruzioni al microcontrollore sulla scheda. Per farlo si utilizza il linguaggio di programmazione Arduino (basato su Wiring) e l'IDE software Arduino ® (basato su Processing). Sono necessari scudi/moduli/componenti aggiuntivi per leggere un messaggio Twitter o pubblicarlo online. Naviga verso www.arduino.cc per ulteriori informazioni.

Prodotto finitoview

Questo scudo si rivelerà utile per la registrazione dei dati con il tuo Arduino®. Può essere facilmente assemblato e personalizzato per qualsiasi progetto di registrazione dati.
Puoi utilizzare questa scheda per accedere alle schede di memoria microSD utilizzando il protocollo SPI nei tuoi progetti di microcontrollore.

Specifiche

• supporta schede microSD (≤ 2 GB) e schede microSDHC (≤ 32 GB) (alta velocità)
• a bordo voltage circuito di conversione di livello che interfaccia i dati voltages tra 5 V dal controller Arduino ® e 3.3 V ai pin dati della scheda SD
• alimentazione: 4.5-5.5 V
• a bordo voltage regolatore 3V3, per voltage circuito di livello
• interfaccia di comunicazione: bus SPI
• 4 fori di posizionamento delle viti M2 per una facile installazione
• misura: 4.1 x 2.4 cm

Cablaggio

Scudo di registrazione	Ad Arduino® Uno	Ad Arduino® Mega
CS (selezione cavo)	4	53
SCK (CLK)	13	52
MOSI	11	51
MISO	12	50
5 V (4.5 V-5.5 V)	5V	5V
Terra	Terra	Terra

Schema elettrico

Operazione

Introduzione
Il modulo scheda SD WPI304N è particolarmente utile per i progetti che richiedono la registrazione dei dati. Arduino ® può creare un file su una scheda SD per scrivere e salvare i dati, utilizzando lo standard SD libreria da Arduino ® IDE. Il modulo WPI304N utilizza il protocollo di comunicazione SPI.
Preparazione della scheda microSD
Il primo passaggio quando si utilizza il modulo della scheda SD WPI304N con Arduino ® è la formattazione della scheda microSD come FAT16 o FAT32 file sistema. Segui le istruzioni di seguito:

1. Inserisci la scheda SD nel tuo computer. Vai su Risorse del computer e fai clic con il pulsante destro del mouse sull'unità rimovibile della scheda SD. Seleziona Formato come mostrato nell'immagine qui sotto.
2. Si apre una nuova finestra. Selezionare FAT32, premere Start per inizializzare il processo di formattazione e seguire le istruzioni sullo schermo.

Utilizzando il modulo della scheda SD
Inserire la scheda microSD formattata nel modulo della scheda SD. Collega il modulo della scheda SD ad Arduino ® Uno come mostrato nel circuito sottostante, oppure controlla la tabella di assegnazione dei pin in una sezione precedente.

Codifica
Informazioni sulla scheda SD
Per assicurarti che tutto sia cablato correttamente e che la scheda SD funzioni, vai a File →Esampfile → SD → CardInfo nel software IDE Arduino®.
Ora carica il codice sulla tua scheda Arduino® Uno. Assicurati di selezionare la scheda e la porta COM corrette. Apri il monitor seriale con baud rate 9600. Normalmente, le informazioni sulla tua scheda microSD verranno presentate nel monitor seriale. Se tutto funziona correttamente, vedrai un messaggio simile sul monitor seriale.

Lettura e scrittura dei dati sulla scheda microSD
La libreria SD fornisce funzioni utili che consentono di scrivere e leggere facilmente su una scheda SD. Apri ReadWrite example da File → Esampfile → SD →  LeggiScrivi e caricalo sulla tua scheda Arduino® Uno.
Codice

1. /*
2. Lettura/scrittura scheda SD
3.
4. Questo esample mostra come leggere e scrivere dati su e da una scheda SD file
5. Il circuito:
6. Scheda SD collegata al bus SPI come segue:
7. ** MOSI – piedino 11
8. ** MISO – perno 12
9. ** CLK – piedino 13
10. ** CS – pin 4 (per MKRZero SD: SDCARD_SS_PIN)
11.
12. creato nel novembre 2010
13. di David A. Mellis
14. modificato il 9 aprile 2012
15. di Tom Igoe
16.
17. Questo esampil codice è di pubblico dominio.
18.
19. */
20.
21. #includi
22. #includi
23.
24. File myFile;
25.
26. impostazione nulla() {
27. // Apri le comunicazioni seriali e attendi che la porta si apra:
28. Serial.begin(9600);
29. while (!Seriale) {
30. ; // attendi che la porta seriale si connetta. Necessario solo per la porta USB nativa
31.}
32.
33.
34. Serial.print(“Inizializzazione scheda SD…”);
35.
36. se (!SD.begin(4)) {
37. Serial.println(“inizializzazione fallita!”);
38. mentre (1);
39.}
40. Serial.println(“inizializzazione eseguita.”);
41.
42. // apri il file. notare che solo uno file può essere aperto alla volta,
43. // quindi devi chiudere questo prima di aprirne un altro.
44. il mioFile = SD.open(“prova.txt”, FILE_SCRIVERE);
45.
46. ​​// se il file aperto ok, scrivici:
47. se (mioFile) {
48. Serial.print(“Scrittura su test.txt…”);
49. il mioFile.println("test 1, 2, 3.");
50. // chiudi il file:
51. il mioFile.vicino();
52. Serial.println("fatto.");
53. } altro {
54. ​​// se il file non si è aperto, stampa un errore:
55. Serial.println(“errore durante l'apertura di test.txt”);
56.}
57.
58. // riapri il file file per leggere:
59. il mioFile = SD.open(“prova.txt”);
60. se (mioFile) {
61. Serial.println(“test.txt:”);
62.
63. // letto dal file fino a quando non c'è nient'altro in esso:
64. mentre (mioFile.disponibile()) {
65. Serial.write(mioFile.Leggere());
66.}
67. // chiudi il file:
68. il mioFile.vicino();
69. } altro {
70. ​​// se il file non si è aperto, stampa un errore:
71. Serial.println(“errore durante l'apertura di test.txt”);
72.}
73.}
74.
75. ciclo vuoto() {
76. // non succede nulla dopo l'installazione
77.}

Una volta che il codice è stato caricato e tutto è a posto, sul monitor seriale appare la seguente finestra.Questo indica che la lettura/scrittura ha avuto successo. Per verificare il files sulla scheda SD, utilizzare Blocco note per aprire TEST.TXT file sulla scheda microSD. I seguenti dati vengono visualizzati in formato .txt:

NonBlockingWrite.ino esample
Nell'originale esample Codice NonBlockingWrite, modifica la riga 48
se (!SD.begin()) {
A
se (!SD.begin(4)) {
Inoltre, aggiungi le seguenti righe dopo la riga 84:
// stampa la lunghezza del buffer. Questo cambierà a seconda di quando
// i dati vengono effettivamente scritti sulla scheda SD file:
Serial.print(“Lunghezza buffer dati non salvati (in byte): “);
Serial.println(buffer.length());
// nota l'ora in cui l'ultima riga è stata aggiunta alla stringa
Il codice completo dovrebbe essere il seguente:

1. /*
2. Scrittura non bloccante
3.
4. Questo esample dimostra come eseguire scritture non bloccanti
5. ad un file su una scheda SD. IL file conterrà l'attuale millis()
6. valore ogni 10ms. Se la scheda SD è occupata, i dati verranno memorizzati nel buffer
7. per non bloccare lo schizzo.
8.
9. NOTA: myFile.availableForWrite() sincronizzerà automaticamente il file
10. file contenuti secondo necessità. Potresti perdere alcuni dati non sincronizzati
11. ancora se il mioFile.sync() o mioFile.close() non viene chiamato.
12.
13. Il circuito:
14. Scheda SD collegata al bus SPI come segue:
15. MOSI – piedino 11
16. MISO – perno 12
17. SCK/CLK – pin 13
18. CS – pin 4 (per MKRZero SD: SDCARD_SS_PIN)
19.
20. Questo esampil codice è di pubblico dominio.
21. */
22.
23. #includi
24.
25. // file nome da utilizzare per la scrittura
26. const car filenome[] = “demo.txt”;
27.
28. // File oggetto da rappresentare file
29. File TXTFile;
30.
31. // stringa per l'output del buffer
32. Buffer di stringhe;
33.
34. ultimoMillis lungo senza segno = 0;
35.
36. impostazione nulla() {
37. Serial.begin(9600);
38. while (!Seriale);
39. Serial.print(“Inizializzazione scheda SD…”);
40.
41. // riserva 1kB per la stringa utilizzata come buffer
42. buffer.reserve(1024);
43.
44. // imposta il pin LED sull'output, utilizzato per lampeggiare durante la scrittura
45. pinMode(LED_BUILTIN, USCITA);
46.
47. // avvia la scheda SD
48. se (!SD.begin(4)) {
49. Serial.println(“Carta guasta o assente”);
50. Serial.println(“inizializzazione fallita. Cose da controllare:”);
51. Serial.println(“1. è inserita una scheda?”);
52. Serial.println(“2. il cablaggio è corretto?”);
53. Serial.println(“3. hai cambiato il pin chipSelect in modo che corrisponda al tuo scudo o
modulo?");
54. Serial.println(“Nota: premere il pulsante di ripristino sulla scheda e riaprire questo monitor seriale
dopo aver risolto il problema!");
55. // non fare più niente:
56. mentre (1);
57.}
58.
59. // Se vuoi iniziare da un vuoto file,
60. // decommenta la riga successiva:
61. // SD.remove(filenome);
62.
63. // prova ad aprire il file per scrivere
64. testoFile = SD.apri(filenome, FILE_SCRIVERE);
65. se (!txtFile) {
66. Serial.print(“errore apertura”);
67. Serial.println(filenome);
68. mentre (1);
69.}
70.
71. // aggiunge alcune nuove righe per iniziare
72. testoFile.println();
73. testoFile.println("Ciao Mondo!");
74. Serial.println(“Inizio a scrivere su file…”);
75.}
76.
77. ciclo vuoto() {
78. // controlla se sono trascorsi più di 10 ms dall'ultima riga aggiunta
79. unsigned long adesso = millis();
80. if ((ora – lastMillis) >= 10) {
81. // aggiunge una nuova riga al buffer
82. buffer += “Ciao “;
83. tampone += ora;
84. buffer += “\r\n”;
85. // stampa la lunghezza del buffer. Questo cambierà a seconda di quando
86. // i dati vengono effettivamente scritti sulla scheda SD file:
87. Serial.print(“Lunghezza buffer dati non salvati (in byte): “);
88. Serial.println(buffer.length());
89. // nota l'ora in cui l'ultima riga è stata aggiunta alla stringa
90. ultimoMillis = adesso;
91.}
92.
93. // controlla se la scheda SD è disponibile per scrivere dati senza bloccare
94. // e se i dati bufferizzati sono sufficienti per l'intera dimensione del blocco
95. unsigned int dimensione pezzo = txtFile.availableForWrite();
96. if (chunkSize && buffer.length() >= chunkSize) {
97. // scrivi a file e LED lampeggiante
98. digitalWrite(LED_BUILTIN, ALTO);
99. testoFile.write(buffer.c_str(), ChunkSize);
100. digitalWrite(LED_BUILTIN, BASSO);
101.
102. // rimuove i dati scritti dal buffer
103. buffer.remove(0, ChunkSize);
104.}
105.}

Con riserva di modifiche ed errori tipografici – © Velleman Group nv. WPI304N_v01
Velleman Group nv, Legen Heirweg 33 – 9890 Gavere.
whadda.com

Documenti / Risorse

WHADDA WPI304N Scudo di registrazione scheda microSD per Arduino [pdf] Manuale d'uso WPI304N Scudo di registrazione scheda microSD per Arduino, WPI304N, Scudo di registrazione scheda microSD per Arduino, Scudo di registrazione scheda, Scudo di registrazione, Scudo

Riferimenti

• Manuale d'uso