यह आलेख Arduino IDE का उपयोग करके ESP32 बोर्ड के साथ माइक्रोएसडी कार्ड को इंटरफ़ेस करने के चरणों की व्याख्या करेगा।
विषयसूची:
2. माइक्रोएसडी कार्ड मॉड्यूल के साथ ESP32 को कैसे इंटरफ़ेस करें
6. ESP32 का उपयोग करके माइक्रोएसडी कार्ड पर विभिन्न कार्य करना
- 6.1. माइक्रोएसडी कार्ड में निर्देशिकाएँ बनाना
- 6.2. माइक्रोएसडी कार्ड में निर्देशिकाओं को सूचीबद्ध करना
- 6.3. निर्देशिकाएँ हटाना
- 6.4. माइक्रोएसडी कार्ड का प्रकार प्राप्त करें
- 6.5. एसडी कार्ड का आकार प्राप्त करें
1. माइक्रोएसडी कार्ड मॉड्यूल
माइक्रोएसडी कार्ड मॉड्यूल एक ESP32 सेंसर है जो एसडी कार्ड को आपके माइक्रोकंट्रोलर बोर्ड से कनेक्ट कर सकता है। यह SPI संचार प्रोटोकॉल पर काम करता है। यह ESP32 या Arduino जैसे किसी अन्य माइक्रोकंट्रोलर बोर्ड को SPI प्रोटोकॉल पर SD कार्ड पर संग्रहीत डेटा तक पहुंचने की अनुमति देता है।
एसडी कार्ड मॉड्यूल के लिए कार्यशील वोल्टेज 3.3V है, इसलिए इसे सीधे ESP32 या किसी अन्य माइक्रोकंट्रोलर बोर्ड से कनेक्ट करना संभव नहीं है। इसके लिए, हमें एसडी कार्ड मॉड्यूल या सेंसर का उपयोग करना होगा जो 5V से अधिक काम करता है।
1.1. बाहर पिन
माइक्रोएसडी कार्ड में कुल छह पिन हैं। उनमें से दो पावर पिन हैं: वीसीसी और जीएनडी। जबकि एसपीआई संचार प्रोटोकॉल के लिए रीडिंग चार पिन का उपयोग किया जाता है। इन सभी छह पिनों का विवरण निम्नलिखित है:
पावर पिन:
- वीसीसी: ESP32 5V पिन से जुड़ता है।
- जीएनडी: ESP32 ग्राउंड (GND) पिन से जुड़ता है।
एसपीआई पिन:
- मीसो: (मास्टर इन स्लेव आउट) ESP32 MOSI (मास्टर आउट स्लेव इन) पिन से जुड़ता है।
- धुआँ: ESP32 MISO (मास्टर इन स्लेव आउट) पिन से जुड़ता है।
- एससीके: ESP32 SCK (सीरियल क्लॉक) पिन से जुड़ता है।
- एसएस: (स्लेव सेलेक्ट) Arduino कोड में निर्दिष्ट पिन से एसएस (स्लेव सेलेक्ट) पिन के रूप में जुड़ता है।
2. माइक्रोएसडी कार्ड मॉड्यूल के साथ ESP32 को कैसे इंटरफ़ेस करें
ESP32 को माइक्रोएसडी कार्ड मॉड्यूल के साथ इंटरफ़ेस करने के लिए, आपको अपने एसडी कार्ड सेंसर के लिए पावर पिन सेट करना होगा। इसके बाद SPI पिन सेट करें। यहां आपके पास दो विकल्प हैं, आप या तो डिफ़ॉल्ट एसपीआई पिन सेट कर सकते हैं या अपने स्वयं के कस्टम एसपीआई पिन परिभाषित कर सकते हैं।
डिफ़ॉल्ट SPI पिन का उपयोग करते समय, हम जोड़ने जा रहे हैं एस.डी. एच और SD_MMC.h पुस्तकालय. डिफ़ॉल्ट रूप से, ये लाइब्रेरी SPI संचार के लिए VSPI SPI पिन (23, 19, 18, 5) लेते हैं। हालाँकि, आप SPI संचार के लिए अन्य पिन भी सेट कर सकते हैं।
ESP32 में दो SPI इंटरफ़ेस HSPI और VSPI शामिल हैं जिनके पिन विवरण इस प्रकार हैं:
| एसपीआई | धुआँ | मीसो | सीएलके | सी |
| वीएसपीआई | D23 | डी19 | डी18 | डी5 |
| एचएसपीआई | डी13 | डी12 | डी14 | डी15 |
संबंधित: ESP32 पिनआउट संदर्भ - एक संपूर्ण मार्गदर्शिका
2.2. एसडी कार्ड तैयार करें
इसके बाद, इससे पहले कि आप माइक्रोएसडी कार्ड पर डेटा पढ़ना और लिखना शुरू करें, आपको पहले इसमें मौजूद किसी भी पिछले डेटा को फ़ॉर्मेट करके इसे सेट करना होगा।
किसी भी कार्ड रीडर का उपयोग करके अपना एसडी कार्ड खोलें प्रारूप यह।
अपने कार्ड फ़ाइल सिस्टम के लिए FAT32 चुनें और क्लिक करें शुरू .
कार्ड को फॉर्मेट करने के बाद सेलेक्ट करें ठीक है .
अब आपका एसडी कार्ड एसडी कार्ड मॉड्यूल का उपयोग करके ईएसपी32 के साथ इंटरफेस करने के लिए तैयार है।
2.3. योजनाबद्ध आरेख
माइक्रोएसडी कार्ड सेंसर को ESP32 से कनेक्ट करने के लिए, नीचे दिए गए कॉन्फ़िगरेशन का पालन करें:
कनेक्शन तार के पिन कॉन्फ़िगरेशन के लिए तालिका निम्नलिखित है:
| माइक्रो एसडी कार्ड | ईएसपी32 |
| जी.एन.डी | जी.एन.डी |
| वी.सी.सी | आना |
| सी | डी5 |
| धुआँ | D23 |
| एससीके | डी18 |
| मीसो | डी19 |
3. हार्डवेयर
हार्डवेयर के लिए, आपको बस ESP32 और SD कार्ड मॉड्यूल के साथ कुछ जम्पर तारों, ब्रेडबोर्ड की आवश्यकता होगी।
4. कोड
अब हम एक कोड लिखेंगे जो माइक्रोएसडी कार्ड के अंदर एक टेक्स्ट फ़ाइल बनाएगा और उसके बाद उसमें कुछ टेक्स्ट स्ट्रिंग लिखेगा। एक बार हो जाने पर, हम Arduino IDE सीरियल मॉनिटर पर टेक्स्ट फ़ाइल की सामग्री को पढ़ेंगे।
Arduino IDE प्रारंभ करें और दिए गए कोड को संकलित करें। उसके बाद इसे अपने ESP32 बोर्ड पर बर्न करें:
#शामिल#शामिल
मेरीफ़ाइल फ़ाइल करें ;
कॉन्स्ट int यहाँ सी = 5 ;
// दिए गए संदेश को निर्दिष्ट पथ पर फ़ाइल में लिखें
खालीपन फ़ाइल लिखें ( कॉन्स्ट चार * पथ , कॉन्स्ट चार * संदेश ) {
// फ़ाइल खोलें। यह एक समय में एक फ़ाइल को खोलने का समर्थन करता है
// नई फ़ाइल खोलने से पहले दूसरी फ़ाइल बंद करें
मेरी फाइल = एस.डी. खुला ( पथ , फ़ाइल_लिखें ) ;
अगर ( मेरी फाइल ) {
धारावाहिक। printf ( '%s को लिख रहा हूँ' , पथ ) ;
मेरी फाइल। println ( संदेश ) ;
मेरी फाइल। बंद करना ( ) ; // फ़ाइल बंद करें
धारावाहिक। println ( 'पुरा होना।' ) ;
} अन्य {
धारावाहिक। println ( 'फ़ाइल खोलने में त्रुटि' ) ;
धारावाहिक। println ( पथ ) ;
}
}
// निर्दिष्ट पथ पर फ़ाइल सामग्री प्रिंट करें
खालीपन फ़ाइल पढ़ें ( कॉन्स्ट चार * पथ ) {
// खुली फाइल
मेरी फाइल = एस.डी. खुला ( पथ ) ;
अगर ( मेरी फाइल ) {
धारावाहिक। printf ( '%s से फ़ाइल पढ़ रहा हूँ \एन ' , पथ ) ;
// आखिरी तक पहुंचने तक पूरी फाइल पढ़ें
जबकि ( मेरी फाइल। उपलब्ध ( ) ) {
धारावाहिक। लिखना ( मेरी फाइल। पढ़ना ( ) ) ;
}
मेरी फाइल। बंद करना ( ) ; // फ़ाइल बंद करें
} अन्य {
// यदि फ़ाइल खुलने में विफल रही, तो एक त्रुटि प्रिंट करें:
धारावाहिक। println ( 'test.txt खोलने में त्रुटि' ) ;
}
}
खालीपन स्थापित करना ( ) {
धारावाहिक। शुरू ( 9600 ) ;
देरी ( 500 ) ;
जबकि ( ! धारावाहिक ) { ; }
धारावाहिक। println ( 'एसडी कार्ड प्रारंभ किया जा रहा है...' ) ;
अगर ( ! एस.डी. शुरू ( सी ) ) {
धारावाहिक। println ( 'प्रारंभ विफल!' ) ;
वापस करना ;
}
धारावाहिक। println ( 'प्रारंभ हो गया।' ) ;
फ़ाइल लिखें ( '/test.txt' , 'Linuxhint.com' ) ;
फ़ाइल पढ़ें ( '/test.txt' ) ;
}
खालीपन कुंडली ( ) {
}
4.1. कोड स्पष्टीकरण
बेहतर समझ के लिए हम इस कोड को उपभागों में विभाजित करेंगे।
आरंभीकरण और सेटअप: सबसे पहले, कोड एसडी कार्ड मॉड्यूल से संबंधित कुछ महत्वपूर्ण पुस्तकालयों को शामिल करके शुरू हुआ। SD कार्ड के साथ संचार के लिए SPI.h लाइब्रेरी और SD कार्ड संचालन को संभालने के लिए SD.h लाइब्रेरी जोड़ी गई है। इसके बाद, यह एक वैश्विक चर को परिभाषित करता है मेरी फाइल फ़ाइल संचालन को प्रबंधित करने के लिए फ़ाइल प्रकार का। सीएस स्थिरांक को पिन 5 पर सेट किया गया है, जिसका उपयोग एसडी कार्ड के लिए चिप सेलेक्ट (सीएस) पिन के रूप में किया जाएगा।
सेटअप() फ़ंक्शन: सेटअप फ़ंक्शन के अंदर, धारावाहिक संचार शुरू हो गया है। उसके बाद, हमने SD.begin(CS) फ़ंक्शन का उपयोग करके SD कार्ड मॉड्यूल को प्रारंभ किया। इसके अलावा, हमने टेक्स्ट फ़ाइल में टेक्स्ट पढ़ने और लिखने के लिए दो अलग-अलग फ़ंक्शन भी परिभाषित किए हैं।
एसडी कार्ड पर लिखना: WriteFile() फ़ंक्शन SD.open(path, FILE_WRITE) का उपयोग करके लिखने के लिए test.txt फ़ाइल खोलता है। उसके बाद, यह myFile.println(message) का उपयोग करके फ़ाइल में Linuxhint.com स्ट्रिंग लिखता है।
एसडी कार्ड से पढ़ना: फ़ाइल सामग्री को पढ़ने के लिए, हमने ReadFile() फ़ंक्शन का उपयोग किया है। यदि सफलतापूर्वक पढ़ा जाता है, तो डेटा Arduino सीरियल पोर्ट पर भेजा जाएगा और Arduino IDE सीरियल मॉनिटर पर प्रदर्शित किया जाएगा।
5. आउटपुट
आउटपुट में, आप वही स्ट्रिंग देख सकते हैं जिसे हमने Arduino IDE कोड के अंदर परिभाषित किया है जो आपके Arduino IDE सीरियल मॉनिटर पर प्रदर्शित होती है।
6. ESP32 का उपयोग करके माइक्रोएसडी कार्ड पर विभिन्न कार्य करना
हम सीधे Arduino IDE कोड के माध्यम से माइक्रोएसडी कार्ड में निर्देशिका बनाने, हटाने या जोड़ने जैसे विभिन्न ऑपरेशन कर सकते हैं।
6.1. माइक्रोएसडी कार्ड में निर्देशिकाएँ बनाना
नीचे दिया गया कोड माइक्रोएसडी कार्ड के अंदर एक नई निर्देशिका बनाएगा। यह नामक एक फ़ंक्शन को परिभाषित करता है createDir यह एक फ़ाइल सिस्टम ऑब्जेक्ट (fs::FS) और इनपुट के रूप में एक पथ लेता है। यह फ़ंक्शन निर्दिष्ट पथ के साथ एक निर्देशिका बनाने का प्रयास करता है और सफलता या विफलता का संकेत देने वाले संदेशों को प्रिंट करता है।
#शामिल 'एफएस.एच'#शामिल है 'एसडी.एच'
#शामिल है 'SPI.h'
खालीपन createDir ( एफ.एस :: एफएस & एफ.एस , कॉन्स्ट चार * पथ ) {
धारावाहिक। printf ( 'निर्देशक बनाया जा रहा है: %s \एन ' , पथ ) ;
अगर ( एफ.एस. mkdir ( पथ ) ) {
धारावाहिक। println ( 'डीर ने बनाया' ) ;
} अन्य {
धारावाहिक। println ( 'एमकेडीआईआर विफल' ) ;
}
}
खालीपन स्थापित करना ( ) {
धारावाहिक। शुरू ( 115200 ) ;
// एसडी कार्ड आरंभ करें
अगर ( ! एस.डी. शुरू ( ) ) {
धारावाहिक। println ( 'कार्ड माउंट विफल' ) ;
वापस करना ;
}
// 'mydir' नामक एक निर्देशिका बनाएं
createDir ( एसडी , '/mydir' ) ;
}
खालीपन कुंडली ( ) {
}
आउटपुट में, आप देख सकते हैं कि एक नई निर्देशिका बनाई गई है /mydir नाम।
6.2. माइक्रोएसडी कार्ड में निर्देशिकाओं को सूचीबद्ध करना
नीचे दिए गए कोड में, हम माइक्रोएसडी कार्ड के अंदर मौजूद सभी निर्देशिकाओं को सूचीबद्ध करने जा रहे हैं। सूचीदिर फ़ंक्शन एसडी कार्ड पर किसी निर्देशिका की सामग्री को पुनरावर्ती रूप से सूचीबद्ध करता है। यह दोनों निर्देशिकाओं ('डीआईआर' के साथ उपसर्ग) और फ़ाइलों ('फ़ाइल' के साथ उपसर्ग) के बारे में जानकारी प्रिंट करता है, जिसमें उनके नाम और आकार भी शामिल हैं।
#शामिल 'एफएस.एच'#शामिल है 'एसडी.एच'
#शामिल है 'SPI.h'
खालीपन सूचीदिर ( एफ.एस :: एफएस & एफ.एस , कॉन्स्ट चार * dirname , uint8_t स्तरों ) {
धारावाहिक। printf ( 'लिस्टिंग निर्देशिका: %s \एन ' , dirname ) ;
फ़ाइल रूट = एफ.एस. खुला ( dirname ) ;
अगर ( ! जड़ ) {
धारावाहिक। println ( 'निर्देशिका खोलने में विफल' ) ;
वापस करना ;
}
अगर ( ! जड़। निर्देशिका है ( ) ) {
धारावाहिक। println ( 'निर्देशिका नहीं' ) ;
वापस करना ;
}
फ़ाइल फ़ाइल = जड़। openNextFile ( ) ;
जबकि ( फ़ाइल ) {
अगर ( फ़ाइल। निर्देशिका है ( ) ) {
धारावाहिक। छपाई ( ' आप : ' ) ;
धारावाहिक। println ( फ़ाइल। नाम ( ) ) ;
अगर ( स्तरों ) {
सूचीदिर ( एफ.एस , फ़ाइल। नाम ( ) , स्तरों - 1 ) ;
}
} अन्य {
धारावाहिक। छपाई ( ' फ़ाइल: ' ) ;
धारावाहिक। छपाई ( फ़ाइल। नाम ( ) ) ;
धारावाहिक। छपाई ( ' आकार: ' ) ;
धारावाहिक। println ( फ़ाइल। आकार ( ) ) ;
}
फ़ाइल = जड़। openNextFile ( ) ;
}
}
खालीपन स्थापित करना ( ) {
धारावाहिक। शुरू ( 115200 ) ;
अगर ( ! एस.डी. शुरू ( ) ) {
धारावाहिक। println ( 'कार्ड माउंट विफल' ) ;
वापस करना ;
}
सूचीदिर ( एसडी , '/' , 0 ) ;
}
खालीपन कुंडली ( ) {
}
आउटपुट में, आप दो अलग-अलग फ़ाइलें देख सकते हैं। एक एक टेक्स्ट फ़ाइल है और दूसरी एक निर्देशिका है जिसे हमने पिछले कोड में बनाया था।
6.3. निर्देशिकाएँ हटाना
अब हम पहले से बनाई गई डायरेक्ट्रीज़ और टेक्स्ट फ़ाइलों को हटा देंगे। इसके लिए हम इसका उपयोग करने जा रहे हैं हटाएँDir फ़ंक्शन, यह पथ द्वारा निर्दिष्ट निर्देशिका को हटाने का प्रयास करेगा। सफल होने पर यह प्रिंट करता है डिर हटा दिया गया ; अन्यथा, यह प्रिंट करता है आरएमडीआईआर विफल .
#शामिल 'एफएस.एच'#शामिल है 'एसडी.एच'
#शामिल है 'SPI.h'
खालीपन हटाएँDir ( एफ.एस :: एफएस & एफ.एस , कॉन्स्ट चार * पथ ) {
धारावाहिक। printf ( 'Dir हटा रहा हूँ: %s \एन ' , पथ ) ;
अगर ( एफ.एस. आरएम है ( पथ ) ) {
धारावाहिक। println ( 'डीआईआर हटा दिया गया' ) ;
} अन्य {
धारावाहिक। println ( 'आरएमडीआईआर विफल' ) ;
}
}
खालीपन स्थापित करना ( ) {
धारावाहिक। शुरू ( 115200 ) ;
अगर ( ! एस.डी. शुरू ( ) ) {
धारावाहिक। println ( 'कार्ड माउंट विफल' ) ;
वापस करना ;
}
}
खालीपन कुंडली ( ) {
}
6.4. माइक्रोएसडी कार्ड का प्रकार प्राप्त करें
माइक्रोएसडी कार्ड या एस सुरक्षित डी इजीटल कार्ड मूल रूप से एसडी कार्ड एसोसिएशन द्वारा डिजाइन किया गया था, और स्मार्टफोन और कैमरे जैसे पोर्टेबल उपकरणों में उपयोग के लिए डिजाइन किया गया था। एसडी कार्ड में मुख्य रूप से चार प्रकार के परिवार होते हैं:
- एसडीएससी (मानक क्षमता एसडी): ये कार्ड 2GB की मामूली भंडारण क्षमता प्रदान करते हैं और FAT-12 और FAT-16 फ़ाइल सिस्टम का उपयोग करते हैं।
- एसडीएचसी (उच्च क्षमता एसडी): ये कार्ड 2GB से 32GB तक के होते हैं और FAT-32 फ़ाइल सिस्टम का उपयोग करते हैं।
- एसडीएक्ससी (विस्तारित क्षमता एसडी): ये कार्ड एक्सफ़ैट फ़ाइल सिस्टम का उपयोग करते हैं और 32GB से शुरू होकर 2TB तक होते हैं।
- एसडीआईओ: एसडीआईओ कार्ड डेटा भंडारण को इनपुट/आउटपुट कार्यों के साथ जोड़कर दोहरे उद्देश्य की पूर्ति करते हैं।
अपना कार्ड प्रकार जांचने के लिए, नीचे दिया गया कोड चलाएँ:
#शामिल 'एफएस.एच'#शामिल है 'एसडी.एच'
#शामिल है 'SPI.h'
खालीपन स्थापित करना ( ) {
धारावाहिक। शुरू ( 115200 ) ;
अगर ( ! एस.डी. शुरू ( ) ) {
धारावाहिक। println ( 'कार्ड माउंट विफल' ) ;
वापस करना ;
}
uint8_t कार्ड का प्रकार = एस.डी. कार्ड का प्रकार ( ) ;
अगर ( कार्ड का प्रकार == कार्ड_कोई नहीं ) {
धारावाहिक। println ( 'कोई एसडी कार्ड संलग्न नहीं है' ) ;
वापस करना ;
}
धारावाहिक। छपाई ( 'एसडी कार्ड प्रकार:' ) ;
अगर ( कार्ड का प्रकार == कार्ड_एमएमसी ) {
धारावाहिक। println ( 'एमएमसी' ) ;
} अन्य अगर ( कार्ड का प्रकार == कार्ड_एसडी ) {
धारावाहिक। println ( 'एसडीएससी' ) ;
} अन्य अगर ( कार्ड का प्रकार == कार्ड_एसडीएचसी ) {
धारावाहिक। println ( 'एसडीएचसी' ) ;
} अन्य {
धारावाहिक। println ( 'अज्ञात' ) ;
}
uint64_t कार्ड का आकार = एस.डी. कार्ड का आकार ( ) / ( 1024 * 1024 ) ;
धारावाहिक। printf ( 'एसडी कार्ड का आकार: %lluMB \एन ' , कार्ड का आकार ) ;
}
खालीपन कुंडली ( ) {
}
जैसा कि मेरे पास 32GB का कार्ड है, आप देख सकते हैं कि यह की रेंज में है एसडीएचसी पत्ते।
6.5. माइक्रोएसडी कार्ड का आकार प्राप्त करें
आप नीचे दिए गए कोड को अपने ESP32 बोर्ड पर अपलोड करके एसडी कार्ड का आकार भी प्राप्त कर सकते हैं।
#शामिल 'एफएस.एच'#शामिल है 'एसडी.एच'
#शामिल है 'SPI.h'
खालीपन स्थापित करना ( ) {
धारावाहिक। शुरू ( 115200 ) ;
अगर ( ! एस.डी. शुरू ( ) ) {
धारावाहिक। println ( 'कार्ड माउंट विफल' ) ;
वापस करना ;
}
uint8_t कार्ड का प्रकार = एस.डी. कार्ड का प्रकार ( ) ;
अगर ( कार्ड का प्रकार == कार्ड_कोई नहीं ) {
धारावाहिक। println ( 'कोई एसडी कार्ड संलग्न नहीं है' ) ;
वापस करना ;
}
uint64_t कार्ड का आकार = एस.डी. कार्ड का आकार ( ) / ( 1024 * 1024 ) ;
धारावाहिक। printf ( 'एसडी कार्ड का आकार: %lluMB \एन ' , कार्ड का आकार ) ;
// अन्य फ़ंक्शन (लिस्टडिर, क्रिएटडिर, रिमूवडिर, आदि) को यहां कॉल किया जा सकता है
}
खालीपन कुंडली ( ) {
}
आउटपुट से, आप देख सकते हैं कि मेरे पास लगभग 30 जीबी का एसडी कार्ड है।
निष्कर्ष
ESP32 बोर्ड का उपयोग करके SD कार्ड से डेटा को पढ़ने और लिखने के लिए एक माइक्रोएसडी कार्ड मॉड्यूल का उपयोग किया जाता है। माइक्रोएसडी कार्ड मॉड्यूल एसपीआई इंटरफ़ेस का उपयोग करके माइक्रोकंट्रोलर के साथ संचार करता है। तो आप या तो एसपीआई लाइब्रेरी का उपयोग कर सकते हैं या कोड के अंदर अपने स्वयं के एसपीआई पिन को परिभाषित कर सकते हैं। एक बार कनेक्ट होने के बाद, आप एक टेक्स्ट फ़ाइल पढ़ सकते हैं, लिख सकते हैं, या अपने एसडी कार्ड में नई निर्देशिकाएँ बना सकते हैं।