Scut de înregistrare a cardului microSD WPI304N pentru Arduino
Manual de utilizare
Scut de înregistrare card microSD pentru Arduino®

WPI304N

Introducere

Tuturor rezidenților Uniunii Europene
Informații importante de mediu despre acest produs
Acest simbol de pe dispozitiv sau de pe ambalaj indică faptul că eliminarea dispozitivului după ciclul său de viață ar putea dăuna mediului. Nu aruncați unitatea (sau bateriile) ca deșeuri municipale nesortate; ar trebui dus la o firma specializata pentru reciclare. Acest dispozitiv trebuie returnat distribuitorului dumneavoastră sau unui serviciu local de reciclare. Respectați regulile locale de mediu.
Dacă aveți îndoieli, contactați autoritățile locale de eliminare a deșeurilor.
Vă mulțumim că ați ales Whadda! Vă rugăm să citiți cu atenție manualul înainte de a pune acest dispozitiv în funcțiune. Dacă dispozitivul a fost deteriorat în timpul transportului, nu îl instalați și nu îl utilizați și contactați distribuitorul.

Instrucțiuni de siguranță

Citiți și înțelegeți acest manual și toate semnele de siguranță înainte de a utiliza acest aparat.
Numai pentru uz interior.

• Acest dispozitiv poate fi utilizat de copii cu vârsta de la 8 ani și peste și de persoane cu capacități fizice, senzoriale sau mentale reduse sau cu lipsă de experiență și cunoștințe dacă au primit supraveghere sau instrucțiuni privind utilizarea dispozitivului într-un mod sigur și înțeleg. pericolele implicate. Copiii nu se vor juca cu dispozitivul. Curățarea și întreținerea utilizatorului nu trebuie efectuate de copii fără supraveghere.

Orientări generale

• Consultați Garanția de service și calitate Velleman® din ultimele pagini ale acestui manual.
• Toate modificările aparatului sunt interzise din motive de siguranță. Daunele cauzate de modificările utilizatorului asupra dispozitivului nu sunt acoperite de garanție.
• Utilizați dispozitivul numai în scopul pentru care a fost destinat. Utilizarea dispozitivului într-un mod neautorizat va anula garanția.
• Daunele cauzate de nerespectarea anumitor instrucțiuni din acest manual nu sunt acoperite de garanție și dealerul nu își asumă responsabilitatea pentru eventualele defecte sau probleme care rezultă.
• Nici Velleman Group nv și nici dealerii săi nu pot fi considerați responsabili pentru orice daune (extraordinare, incidentale sau indirecte) – de orice natură (financiare, fizice…) care decurg din deținerea, utilizarea sau defecțiunea acestui produs.
• Păstrați acest manual pentru referințe viitoare.

Ce este Arduino®

Arduino ® este o platformă de prototipare open-source bazată pe hardware și software ușor de utilizat. Plăcile Arduino ® sunt capabile să citească intrări – senzor de lumină, un deget pe un buton sau un mesaj Twitter – și să le transforme într-o ieșire – activarea unui motor, aprinderea unui LED, publicarea ceva online. Puteți spune plăcii dvs. ce să facă trimițând un set de instrucțiuni microcontrolerului de pe placă. Pentru a face acest lucru, utilizați limbajul de programare Arduino (bazat pe Cablare) și IDE-ul software Arduino ® (bazat pe Procesare). Sunt necesare scuturi/module/componente suplimentare pentru citirea unui mesaj Twitter sau publicarea online. Surf la www.arduino.cc pentru mai multe informații.

Produs terminatview

Acest scut se va dovedi util pentru înregistrarea datelor cu Arduino®. Poate fi ușor asamblat și personalizat pentru orice proiect de înregistrare a datelor.
Puteți utiliza acest card pentru a accesa cardurile de memorie microSD folosind protocolul SPI în proiectele dvs. de microcontroler.

Specificații

• acceptă carduri microSD (≤ 2 GB) și carduri microSDHC (≤ 32 GB) (de mare viteză)
• la bord voltage circuit de conversie de nivel care interfață datele voltageste între 5 V de la controlerul Arduino ® și 3.3 V la pinii de date ale cardului SD
• alimentare: 4.5-5.5 V
• la bord voltage regulator 3V3, pentru voltage circuit de nivel
• interfață de comunicare: magistrală SPI
• 4 orificii de poziționare a șuruburilor M2 pentru o instalare ușoară
• dimensiune: 4.1 x 2.4 cm

Cablaj

Scut de tăiere	La Arduino® Uno	La Arduino ® Mega
CS (selectare cablu)	4	53
SCK (CLK)	13	52
MOSI	11	51
MISO	12	50
5 V (4.5 V-5.5 V)	5V	5V
GND	GND	GND

Schema circuitului

Operațiunea

Introducere
Modulul cardului SD WPI304N este util în special pentru proiectele care necesită înregistrarea datelor. Arduino ® poate crea un file pe un card SD pentru a scrie și a salva date, folosind standardul SD biblioteca de la Arduino ® IDE. Modulul WPI304N utilizează protocolul de comunicare SPI.
Pregătirea cardului microSD
Primul pas atunci când utilizați modulul cardului SD WPI304N cu Arduino®, este formatarea cardului microSD ca FAT16 sau FAT32. file sistem. Urmați instrucțiunile de mai jos:

1. Introduceți cardul SD în computer. Accesați My Computer și faceți clic dreapta pe unitatea detașabilă a cardului SD. Selectați Format așa cum se arată în imaginea de mai jos.
2. Apare o fereastră nouă. Selectați FAT32, apăsați Start pentru a inițializa procesul de formatare și urmați instrucțiunile de pe ecran.

Folosind modulul cardului SD
Introduceți cardul microSD formatat în modulul cardului SD. Conectați modulul cardului SD la Arduino ® Uno, așa cum se arată în circuitul de mai jos, sau verificați tabelul de alocare a pinilor din secțiunea anterioară.

Codificare
Informații card SD
Pentru a vă asigura că totul este conectat corect și cardul SD funcționează, accesați File →Exampfișiere → SD → CardInfo în software-ul Arduino ® IDE.
Acum, încărcați codul pe placa dvs. Arduino® Uno. Asigurați-vă că selectați placa și portul COM potrivite. Deschideți monitorul serial cu viteza de transmisie 9600. În mod normal, informațiile cardului dvs. microSD vor fi prezentate pe monitorul serial. Dacă totul funcționează corect, veți vedea un mesaj similar pe monitorul serial.

Citirea și scrierea datelor pe cardul microSD
Biblioteca SD oferă funcții utile care vă permit să scrieți și să citiți cu ușurință de pe un card SD. Deschideți ex. ReadWriteample de la File → Examples → SD →  Citiți Scrieți și încărcați-l pe placa dvs. Arduino® Uno.
Cod

1. /*
2. Citire/scriere pe card SD
3.
4. Acest exampfișierul arată cum să citiți și să scrieți date pe și de pe un card SD file
5. Circuitul:
6. Card SD atașat la magistrala SPI după cum urmează:
7. ** MOSI – pin 11
8. ** MISO – pin 12
9. ** CLK – pin 13
10. ** CS – pin 4 (pentru MKRZero SD: SDCARD_SS_PIN)
11.
12. creat în noiembrie 2010
13. de David A. Mellis
14. modificat 9 apr 2012
15. de Tom Igoe
16.
17. Acest exampcodul este în domeniul public.
18.
19. */
20.
21. #include
22. #include
23.
24. File myFile;
25.
26. void setup() {
27. // Deschideți comunicațiile seriale și așteptați ca portul să se deschidă:
28. Serial.begin(9600);
29. în timp ce (!Serial) {
30. ; // așteptați conectarea portului serial. Este necesar doar pentru portul USB nativ
31.}
32.
33.
34. Serial.print(„Se inițializează cardul SD…”);
35.
36. dacă (!SD.begin(4)) {
37. Serial.println(„inițializarea a eșuat!”);
38. în timp ce (1);
39.}
40. Serial.println(„inițializarea s-a făcut.”);
41.
42. // deschide file. rețineți că doar unul file poate fi deschis la un moment dat,
43. // deci trebuie să-l închideți pe acesta înainte de a deschide altul.
44. meaFile = SD.open(„test.txt”, FILE_SCRIE);
45.
46. ​​// dacă file deschis bine, scrie-i:
47. dacă (al meuFile) {
48. Serial.print(„Se scrie pentru a testa.txt…”);
49. meaFile.println(„testarea 1, 2, 3.”);
50. // închide file:
51. meaFile.aproape();
52. Serial.println(„terminat.”);
53. } else {
54. ​​// dacă file nu s-a deschis, imprimați o eroare:
55. Serial.println(„eroare la deschiderea test.txt”);
56.}
57.
58. // redeschide file pentru citit:
59. meaFile = SD.open(„test.txt”);
60. dacă (al meuFile) {
61. Serial.println(“test.txt:”);
62.
63. // citit din file până nu este nimic altceva în el:
64. în timp ce (al meuFile.disponibil()) {
65. Serial.write(myFile.citire());
66.}
67. // închide file:
68. meaFile.aproape();
69. } else {
70. ​​// dacă file nu s-a deschis, imprimați o eroare:
71. Serial.println(„eroare la deschiderea test.txt”);
72.}
73.}
74.
75. void loop() {
76. // nu se întâmplă nimic după configurare
77.}

Odată ce codul este încărcat și totul este în regulă, pe monitorul serial apare următoarea fereastră.Aceasta indică faptul că citirea/scrierea a avut succes. Pentru a verifica despre files pe cardul SD, utilizați Notepad pentru a deschide TEST.TXT file pe cardul microSD. Următoarele date apar în format .txt:

NonBlockingWrite.ino example
În ex. originalampcodul NonBlockingWrite, schimbați linia 48
dacă (!SD.begin()) {
la
dacă (!SD.begin(4)) {
De asemenea, adăugați următoarele rânduri după rândul 84:
// imprimă lungimea tamponului. Acest lucru se va schimba în funcție de când
// datele sunt de fapt scrise pe cardul SD file:
Serial.print ("Lungimea bufferului de date nesalvat (în octeți): ");
Serial.println(buffer.length());
// notează ora la care ultima linie a fost adăugată la șir
Codul complet ar trebui să fie după cum urmează:

1. /*
2. Scriere fără blocare
3.
4. Acest example demonstrează cum se efectuează scrieri neblocante
5. la a file pe un card SD. The file va conține milis () curent
6. valoare la fiecare 10ms. Dacă cardul SD este ocupat, datele vor fi stocate în tampon
7. pentru a nu bloca schița.
8.
9. NOTĂ: al meuFile.availableForWrite() va sincroniza automat
10. file conținut după cum este necesar. Este posibil să pierdeți unele date nesincronizate
11. tot daca al meuFile.sync() sau myFile.close() nu este apelat.
12.
13. Circuitul:
14. Card SD atașat la magistrala SPI după cum urmează:
15. MOSI – pin 11
16. MISO – pin 12
17. SCK / CLK – pin 13
18. CS – pin 4 (pentru MKRZero SD: SDCARD_SS_PIN)
19.
20. Acest exampcodul este în domeniul public.
21. */
22.
23. #include
24.
25. // file nume de folosit pentru scris
26. const char filenume[] = „demo.txt”;
27.
28. // File obiect de reprezentat file
29. File TXTFile;
30.
31. // șir de ieșire în tampon
32. Buffer de șiruri;
33.
34. nesemnat lung lastMillis = 0;
35.
36. void setup() {
37. Serial.begin(9600);
38. în timp ce (!Serial);
39. Serial.print(„Se inițializează cardul SD…”);
40.
41. // rezervă 1kB pentru String folosit ca buffer
42. buffer.reserve(1024);
43.
44. // setați pinul LED-ului la ieșire, folosit pentru a clipi când scrieți
45. pinMode(LED_BUILTIN, OUTPUT);
46.
47. // porniți cardul SD
48. dacă (!SD.begin(4)) {
49. Serial.println(„Card a eșuat sau nu este prezent”);
50. Serial.println(„inițializarea a eșuat. Lucruri de verificat:”);
51. Serial.println(„1. este introdus un card?”);
52. Serial.println(„2. este cablarea dvs. corectă?”);
53. Serial.println(“3. ai schimbat pinul chipSelect pentru a se potrivi cu scutul sau
modul?");
54. Serial.println(„Notă: apăsați butonul de resetare de pe placă și redeschideți acest monitor serial
după ce ați rezolvat problema!”);
55. // nu mai face nimic:
56. în timp ce (1);
57.}
58.
59. // Dacă vrei să începi de la un gol file,
60. // decomentează următoarea linie:
61. // SD.eliminare(filenume);
62.
63. // încercați să deschideți file pentru scris
64. txtFile = SD.deschis(filenume, FILE_SCRIE);
65. dacă (!txtFile) {
66. Serial.print(„eroare de deschidere”);
67. Serial.println(filenume);
68. în timp ce (1);
69.}
70.
71. // adaugă câteva linii noi pentru a începe
72. txtFile.println();
73. txtFile.println(„Bună lume!”);
74. Serial.println(„Începe să scriu la file…”);
75.}
76.
77. void loop() {
78. // verifică dacă au trecut peste 10 ms de la ultima linie adăugată
79. unsigned long now = millis();
80. dacă ((acum – lastMillis) >= 10) {
81. // adaugă o nouă linie în buffer
82. buffer += „Bună”;
83. tampon += acum;
84. buffer += „\r\n”;
85. // imprimă lungimea tamponului. Acest lucru se va schimba în funcție de când
86. // datele sunt de fapt scrise pe cardul SD file:
87. Serial.print(„Lungimea bufferului de date nesalvată (în octeți):”);
88. Serial.println(buffer.length());
89. // notează ora la care ultima linie a fost adăugată la șir
90. lastMillis = acum;
91.}
92.
93. // verifică dacă cardul SD este disponibil pentru a scrie date fără blocare
94. // și dacă datele din buffer sunt suficiente pentru dimensiunea completă a fragmentului
95. unsigned int chunkSize = txtFile.availableForWrite();
96. dacă (dimensiune bucată && buffer.lungime() >= Dimensiune bucată) {
97. // scrie la file și LED-ul clipește
98. digitalWrite(LED_BUILTIN, HIGH);
99. txtFile.write(buffer.c_str(), chunkSize);
100. digitalWrite(LED_BUILTIN, LOW);
101.
102. // elimină datele scrise din buffer
103. buffer.remove(0, chunkSize);
104.}
105.}

Rezervat modificări și erori de tipar – © Velleman Group nv. WPI304N_v01
Velleman Group nv, Legen Heirweg 33 – 9890 Gavere.
whadd.com

Documente/Resurse

WHADDA WPI304N scut de înregistrare card microSD pentru Arduino [pdfManual de utilizare WPI304N scut de înregistrare card microSD pentru Arduino, WPI304N, scut de înregistrare card microSD pentru Arduino, scut de înregistrare card, scut de înregistrare, scut

Referințe

• Manual de utilizare