WHADDA WPI304N microSD Card Logging Shield for Arduino მომხმარებლის სახელმძღვანელო

WPI304N microSD ბარათის აღრიცხვის ფარი Arduino-სთვის
მომხმარებლის სახელმძღვანელო
microSD ბარათის აღრიცხვის ფარი Arduino®-სთვის

WPI304N

შინაარსი დამალვა

1 შესავალი

2 უსაფრთხოების ინსტრუქციები

3 ზოგადი გაიდლაინები

4 პროდუქტი დასრულდაview

5 სპეციფიკაციები

6 მიკროსქემის დიაგრამა

7 ოპერაცია

8 დოკუმენტები / რესურსები

8.1 ცნობები

9 დაკავშირებული პოსტები

შესავალი

ევროკავშირის ყველა მცხოვრებს
მნიშვნელოვანი გარემოსდაცვითი ინფორმაცია ამ პროდუქტის შესახებ
ეს სიმბოლო მოწყობილობაზე ან შეფუთვაზე მიუთითებს, რომ მოწყობილობის განადგურებამ მისი სიცოცხლის ციკლის შემდეგ შეიძლება ზიანი მიაყენოს გარემოს. არ გადააგდოთ მოწყობილობა (ან ბატარეები), როგორც დაუხარისხებელი მუნიციპალური ნარჩენები; ის გადასამუშავებლად სპეციალიზირებულ კომპანიაში უნდა გადაიტანოთ. ეს მოწყობილობა უნდა დაუბრუნდეს თქვენს დისტრიბუტორს ან ადგილობრივ გადამუშავების სერვისს. დაიცავით ადგილობრივი გარემოსდაცვითი წესები.
თუ ეჭვი გეპარებათ, დაუკავშირდით ნარჩენების განადგურების ადგილობრივ ორგანოებს.
გმადლობთ Whadda-ს არჩევისთვის! გთხოვთ, ყურადღებით წაიკითხოთ სახელმძღვანელო ამ მოწყობილობის ექსპლუატაციაში გამოყენებამდე. თუ მოწყობილობა დაზიანდა ტრანსპორტის დროს, არ დააინსტალიროთ ან გამოიყენოთ იგი და დაუკავშირდით თქვენს დილერს.

უსაფრთხოების ინსტრუქციები

წაიკითხეთ და გაიგეთ ეს სახელმძღვანელო და უსაფრთხოების ყველა ნიშანი ამ მოწყობილობის გამოყენებამდე.
მხოლოდ შიდა გამოყენებისთვის.

ამ ხელსაწყოს გამოყენება შეუძლიათ 8 წელზე უფროსი ასაკის ბავშვებს და შემცირებული ფიზიკური, სენსორული ან გონებრივი შესაძლებლობების ან გამოცდილების და ცოდნის ნაკლებობის მქონე პირებს, თუ მათ მიეცათ ზედამხედველობა ან ინსტრუქცია მოწყობილობის უსაფრთხოდ გამოყენებასთან დაკავშირებით. დაკავშირებული საფრთხეები. ბავშვებმა არ უნდა ითამაშონ მოწყობილობასთან. დასუფთავება და მომხმარებლის მოვლა არ უნდა განხორციელდეს ბავშვების მიერ მეთვალყურეობის გარეშე.

ზოგადი გაიდლაინები

იხილეთ Velleman® სერვისისა და ხარისხის გარანტია ამ სახელმძღვანელოს ბოლო გვერდებზე.
უსაფრთხოების მიზეზების გამო აკრძალულია მოწყობილობის ყველა მოდიფიკაცია. მომხმარებლის მიერ მოწყობილობის მოდიფიკაციებით გამოწვეული დაზიანება არ ვრცელდება გარანტიით.

გამოიყენეთ მოწყობილობა მხოლოდ მისი დანიშნულებისამებრ. მოწყობილობის არასანქცირებული გზით გამოყენება გააუქმებს გარანტიას.
ამ სახელმძღვანელოში მოცემული გარკვეული მითითებების უგულებელყოფით გამოწვეული ზიანი არ ვრცელდება გარანტიით და დილერი არ მიიღებს პასუხისმგებლობას ნებისმიერ დეფექტზე ან პრობლემაზე.

არც Velleman Group nv და არც მისი დილერები არ შეიძლება იყოს პასუხისმგებელი ამ პროდუქტის ფლობის, გამოყენების ან წარუმატებლობის შედეგად წარმოქმნილი რაიმე სახის (არაჩვეულებრივი, შემთხვევითი ან არაპირდაპირი) ზარალზე (ფინანსური, ფიზიკური…).
შეინახეთ ეს სახელმძღვანელო მომავალი მითითებისთვის.

რა არის Arduino®

Arduino ® არის ღია კოდის პროტოტიპის პლატფორმა, რომელიც დაფუძნებულია ადვილად გამოსაყენებელ აპარატურასა და პროგრამულ უზრუნველყოფაზე. Arduino ® დაფებს შეუძლიათ წაიკითხონ შეყვანები - განათების სენსორი, ღილაკზე თითის დაჭერა ან Twitter-ის შეტყობინება - და გადააკეთონ ის გამოსავალად - ძრავის გააქტიურება, LED-ის ჩართვა, რაღაცის ინტერნეტში გამოქვეყნება. თქვენ შეგიძლიათ უთხრათ თქვენს დაფას, რა უნდა გააკეთოს დაფაზე არსებული მიკროკონტროლერისთვის ინსტრუქციების ნაკრების გაგზავნით. ამისათვის თქვენ იყენებთ Arduino პროგრამირების ენას (დაფუძნებული Wiring) და Arduino ® პროგრამული უზრუნველყოფის IDE (დამუშავების საფუძველზე). დამატებითი ფარები/მოდულები/კომპონენტები საჭიროა Twitter-ის შეტყობინების წასაკითხად ან ონლაინ გამოქვეყნებისთვის. სერფინგი რომ www.arduino.cc დამატებითი ინფორმაციისთვის.

პროდუქტი დასრულდაview

ეს ფარი სასარგებლო იქნება თქვენი Arduino®-ით მონაცემთა აღრიცხვისთვის. შეიძლება ადვილად აწყობილი და მორგებული იყოს მონაცემთა აღრიცხვის ნებისმიერი პროექტისთვის.
თქვენ შეგიძლიათ გამოიყენოთ ეს ბარათი microSD მეხსიერების ბარათებზე წვდომისთვის SPI პროტოკოლის გამოყენებით თქვენს მიკროკონტროლერ პროექტებში.

სპეციფიკაციები

მხარს უჭერს microSD (≤ 2 GB) და microSDHC ბარათებს (≤ 32 GB) (მაღალსიჩქარიანი)

საბორტო ტtage დონის კონვერტაციის წრე, რომელიც აკავშირებს მონაცემთა ტომსtagარის 5 ვ-ს შორის Arduino ® კონტროლერიდან და 3.3 V-დან SD ბარათის მონაცემთა პინებთან
კვების წყარო: 4.5-5.5 ვ

საბორტო ტtage რეგულატორი 3V3, ტომისთვისtagე დონის წრე
საკომუნიკაციო ინტერფეისი: SPI ავტობუსი

4x M2 ხრახნიანი პოზიციონირების ხვრელები მარტივი ინსტალაციისთვის
ზომა: 4.1 x 2.4 სმ

გაყვანილობა

ხე-ტყის ფარი	Arduino® Uno-სკენ	Arduino ® Mega-სკენ
CS (კაბელის არჩევა)	4	53
SCK (CLK)	13	52
MOSI	11	51
მისო	12	50
5V (4.5V-5.5V)	5V	5V
GND	GND	GND

მიკროსქემის დიაგრამა

ოპერაცია

შესავალი
WPI304N SD ბარათის მოდული განსაკუთრებით სასარგებლოა პროექტებისთვის, რომლებიც საჭიროებენ მონაცემთა აღრიცხვას. Arduino ®-ს შეუძლია შექმნას file SD ბარათზე მონაცემების ჩასაწერად და შესანახად, ტანდარტის გამოყენებით SD ბიბლიოთეკა Arduino ® IDE-დან. WPI304N მოდული იყენებს SPI საკომუნიკაციო პროტოკოლს.
microSD ბარათის მომზადება
პირველი ნაბიჯი WPI304N SD ბარათის მოდულის Arduino ®-ით გამოყენებისას არის microSD ბარათის ფორმატირება, როგორც FAT16 ან FAT32. file სისტემა. მიჰყევით ქვემოთ მოცემულ ინსტრუქციას:

ჩადეთ SD ბარათი თქვენს კომპიუტერში. გადადით ჩემს კომპიუტერზე და დააწკაპუნეთ მარჯვენა ღილაკით SD ბარათის მოსახსნელ დისკზე. აირჩიეთ ფორმატი, როგორც ნაჩვენებია ქვემოთ მოცემულ სურათზე.
ჩნდება ახალი ფანჯარა. აირჩიეთ FAT32, დააჭირეთ დაწყებას ფორმატირების პროცესის ინიციალიზაციისთვის და მიჰყევით ეკრანზე მითითებებს.

SD ბარათის მოდულის გამოყენებით
ჩადეთ ფორმატირებული microSD ბარათი SD ბარათის მოდულში. შეაერთეთ SD ბარათის მოდული Arduino ® Uno-სთან, როგორც ეს ნაჩვენებია ქვემოთ მოცემულ წრეში, ან შეამოწმეთ პინების მინიჭების ცხრილი წინა განყოფილებაში.

კოდირება
SD ბარათის ინფორმაცია
იმისათვის, რომ დარწმუნდეთ, რომ ყველაფერი სწორად არის გაყვანილი და SD ბარათი მუშაობს, გადადით File → მაგamples → SD → CardInfo Arduino ® IDE პროგრამულ უზრუნველყოფაში.
ახლა, ატვირთეთ კოდი თქვენს Arduino® Uno დაფაზე. დარწმუნდით, რომ აირჩიეთ სწორი დაფა და COM პორტი. გახსენით სერიული მონიტორი ბაუდის სიჩქარით 9600. ჩვეულებრივ, თქვენი microSD ბარათის ინფორმაცია წარმოდგენილი იქნება სერიულ მონიტორზე. თუ ყველაფერი გამართულად მუშაობს, მსგავს შეტყობინებას ნახავთ სერიულ მონიტორზე.

მონაცემების წაკითხვა და ჩაწერა microSD ბარათზე
SD ბიბლიოთეკა უზრუნველყოფს სასარგებლო ფუნქციებს, რაც საშუალებას გაძლევთ მარტივად ჩაწეროთ და წაიკითხოთ SD ბარათზე. გახსენით ReadWrite example საწყისი File → მაგamples → SD → წაიკითხე დაწერე და ატვირთეთ იგი თქვენს Arduino® Uno დაფაზე.
კოდი

1. /*
2. SD ბარათის წაკითხვა/ჩაწერა
3.
4. ეს ყოფილიample გვიჩვენებს, თუ როგორ უნდა წაიკითხოთ და ჩაწეროთ მონაცემები SD ბარათზე და მის გარეთ file
5. წრე:
6. SPI ავტობუსზე მიმაგრებული SD ბარათი შემდეგნაირად:
7. ** MOSI – პინი 11
8. ** MISO – პინი 12
9. ** CLK – პინი 13
10. ** CS – პინი 4 (MKRZero SD-სთვის: SDCARD_SS_PIN)
11.
12. შეიქმნა 2010 წლის ნოემბერი
13. დევიდ ა.მელისის მიერ
14. შეცვლილია 9 წლის 2012 აპრილს
15. ტომ იგოეს მიერ
16.
17. ეს ყოფილიample კოდი არის საზოგადოებრივ დომენში.
18.
19. */
20.
21. #შეიცავს
22. #შეიცავს
23.
24. File myFile;
25.
26. void setup() {
27. // გახსენით სერიული კომუნიკაციები და დაელოდეთ პორტის გახსნას:
28. Serial.begin(9600);
29. ხოლო (!სერიალი) {
30. ; // დაელოდეთ სერიული პორტის დაკავშირებას. საჭიროა მხოლოდ USB პორტისთვის
31.}
32.
33.
34. Serial.print (“SD ბარათის ინიციალიზაცია…”);
35.
36. თუ (!SD.begin(4)) {
37. Serial.println(„ინიციალიზაცია ვერ მოხერხდა!“);
38. ხოლო (1);
39.}
40. Serial.println(“ინიციალიზაცია შესრულებულია.”);
41.
42. // გახსენით file. გაითვალისწინეთ, რომ მხოლოდ ერთი file შეიძლება ერთდროულად იყოს გახსნილი,
43. // ასე რომ თქვენ უნდა დახუროთ ეს მეორის გახსნამდე.
44. ჩემიFile = SD.open("test.txt", FILE_WRITE);
45.
46. // თუ file გაიხსნა კარგად, დაწერე:
47. თუ (ჩემიFile) {
48. Serial.print (“Writing to test.txt…”);
49. ჩემიFile.println ("ტესტირება 1, 2, 3.");
50. // დახურეთ file:
51. ჩემიFile.close();
52. Serial.println(“შესრულებულია.”);
53. } სხვა {
54. // თუ file არ გაიხსნა, დაბეჭდეთ შეცდომა:
55. Serial.println („შეცდომა გახსნის test.txt“);
56.}
57.
58. // ხელახლა გახსნა file წასაკითხად:
59. ჩემიFile = SD.open ("test.txt");
60. თუ (ჩემიFile) {
61. Serial.println(“test.txt:”);
62.
63. // წაკითხულიდან file სანამ მასში სხვა არაფერია:
64. ხოლო (ჩემიFile.ხელმისაწვდომია()) {
65. სერიალი.წერე(ჩემიFile.read());
66.}
67. // დახურეთ file:
68. ჩემიFile.close();
69. } სხვა {
70. // თუ file არ გაიხსნა, დაბეჭდეთ შეცდომა:
71. Serial.println („შეცდომა გახსნის test.txt“);
72.}
73.}
74.
75. void loop() {
76. // დაყენების შემდეგ არაფერი ხდება
77.}

კოდის ატვირთვის შემდეგ და ყველაფერი წესრიგშია, სერიულ მონიტორზე გამოჩნდება შემდეგი ფანჯარა.ეს მიუთითებს, რომ კითხვა/წერა წარმატებული იყო. შესამოწმებლად შესახებ files SD ბარათზე, გამოიყენეთ Notepad TEST.TXT-ის გასახსნელად file microSD ბარათზე. შემდეგი მონაცემები გამოჩნდება .txt ფორმატში:

NonBlockingWrite.ino example
ორიგინალში ყოფილიample NonBlockingWrite კოდი, შეცვალეთ ხაზი 48
if (!SD.begin()) {
რომ
if (!SD.begin(4)) {
ასევე, დაამატეთ შემდეგი სტრიქონები 84-ე სტრიქონის შემდეგ:
// ბუფერის სიგრძის ამობეჭდვა. ეს შეიცვლება იმის მიხედვით, თუ როდის
// მონაცემები რეალურად იწერება SD ბარათზე file:
Serial.print(“Unserved data buffer length (bytes):“);
Serial.println(buffer.length());
// გაითვალისწინეთ დრო, როდესაც ბოლო ხაზი დაემატა სტრიქონს
სრული კოდი უნდა იყოს შემდეგი:

1. /*
2. დაუბლოკავი ჩაწერა
3.
4. ეს ყოფილიample გვიჩვენებს, თუ როგორ უნდა შეასრულოთ არა-დაბლოკვის ჩაწერა
5. ა file SD ბარათზე. The file შეიცავს მიმდინარე millis()
6. მნიშვნელობა ყოველ 10 ms. თუ SD ბარათი დაკავებულია, მონაცემები ბუფერული იქნება
7. რათა არ დაიბლოკოს ესკიზი.
8.
9. შენიშვნა: ჩემიFile.availableForWrite() ავტომატურად მოახდინებს სინქრონიზაციას
10. file შიგთავსი საჭიროებისამებრ. შეიძლება დაკარგოთ ზოგიერთი არასინქრონული მონაცემი
11. მაინც თუ ჩემიFile.sync() ან ჩემიFile.close() არ არის გამოძახებული.
12.
13. წრე:
14. SPI ავტობუსზე მიმაგრებული SD ბარათი შემდეგნაირად:
15. MOSI – პინი 11
16. MISO – პინი 12
17. SCK / CLK – პინი 13
18. CS – პინი 4 (MKRZero SD-სთვის: SDCARD_SS_PIN)
19.
20. ეს ყოფილიample კოდი არის საზოგადოებრივ დომენში.
21. */
22.
23. #შეიცავს
24.
25. // file წერისთვის გამოსაყენებელი სახელი
26. კონსტ char filename[] = “demo.txt”;
27.
28. // File წარმოდგენის ობიექტი file
29. File txtFile;
30.
31. // სტრიქონი ბუფერულ გამოსავალზე
32. სიმებიანი ბუფერი;
33.
34. ხელმოუწერელი long lastMillis = 0;
35.
36. void setup() {
37. Serial.begin(9600);
38. ხოლო (!სერიალი);
39. Serial.print (“SD ბარათის ინიციალიზაცია…”);
40.
41. // რეზერვი 1 კბ სიმისთვის, რომელიც გამოიყენება ბუფერად
42. ბუფერი.რეზერვი(1024);
43.
44. // დააყენეთ LED პინი გამოსავალზე, გამოიყენება წერის დროს ციმციმებისთვის
45. pinMode(LED_BUILTIN, OUTPUT);
46.
47. // ჩადეთ SD ბარათი
48. თუ (!SD.begin(4)) {
49. Serial.println(„ბარათი წარუმატებელია, ან არ არის“);
50. Serial.println(“ინიციალიზაცია ვერ მოხერხდა. შესამოწმებელი რამ:”);
51. Serial.println(“1. ჩასმულია ბარათი?”);
52. Serial.println(“2. არის თქვენი გაყვანილობა სწორი?”);
53. Serial.println(“3. შეცვალეთ ჩიპის არჩევის პინი თქვენი ფარის შესატყვისად ან
მოდული?”);
54. Serial.println(„შენიშვნა: დააჭირეთ გადატვირთვის ღილაკს დაფაზე და ხელახლა გახსენით ეს სერიული მონიტორი
თქვენი პრობლემის მოგვარების შემდეგ!”);
55. // მეტი არაფერი გააკეთო:
56. ხოლო (1);
57.}
58.
59. // თუ გსურთ ცარიელიდან დაწყება file,
60. // გააუქმეთ შემდეგი ხაზი:
61. // SD.remove(fileსახელი);
62.
63. // სცადე გახსნა file წერისთვის
64. txtFile = SD.open(fileსახელი, FILE_WRITE);
65. თუ (!txtFile) {
66. Serial.print („შეცდომის გახსნა“);
67. Serial.println(fileსახელი);
68. ხოლო (1);
69.}
70.
71. // დაამატეთ რამდენიმე ახალი ხაზი დასაწყებად
72. txtFile.println();
73. txtFile.println ("Hello World!");
74. Serial.println(„დაწყებული წერა file...");
75.}
76.
77. void loop() {
78. // შეამოწმეთ, გავიდა თუ არა 10 ms-ზე მეტი ბოლო ხაზის დამატებიდან
79. unsigned long now = millis();
80. თუ ((ახლა – ბოლო მილისი) >= 10) {
81. // დაამატეთ ახალი ხაზი ბუფერში
82. ბუფერი += „გამარჯობა“;
83. ბუფერი += ახლა;
84. ბუფერი += „\r\n“;
85. // ამობეჭდეთ ბუფერის სიგრძე. ეს შეიცვლება იმის მიხედვით, თუ როდის
86. // მონაცემები რეალურად იწერება SD ბარათზე file:
87. Serial.print(“Unsaved data buffer length (bytes):“);
88. Serial.println(buffer.length());
89. // გაითვალისწინეთ დრო, როდესაც ბოლო ხაზი დაემატა სტრიქონს
90. lastMillis = ახლა;
91.}
92.
93. // შეამოწმეთ არის თუ არა SD ბარათი ხელმისაწვდომი მონაცემების დაბლოკვის გარეშე ჩასაწერად
94. // და თუ ბუფერული მონაცემები საკმარისია სრული ბლოკის ზომისთვის
95. ხელმოუწერელი int chunkSize = txtFile.availableForWrite();
96. if (chunkSize && buffer.length() >= chunkSize) {
97. // დაწერე file და აციმციმებს LED
98. digitalWrite(LED_BUILTIN, HIGH);
99. txtFile.write(buffer.c_str(), chunkSize);
100. digitalWrite(LED_BUILTIN, LOW);
101.
102. // ამოიღეთ დაწერილი მონაცემები ბუფერიდან
103. buffer.remove(0, chunkSize);
104.}
105.}