Arduino IDEని ఉపయోగించి ESP32 బోర్డుతో మైక్రో SD కార్డ్‌ని ఇంటర్‌ఫేస్ చేసే దశలను ఈ కథనం వివరిస్తుంది.
విషయ సూచిక:
2. మైక్రో SD కార్డ్ మాడ్యూల్‌తో ESP32ని ఎలా ఇంటర్‌ఫేస్ చేయాలి
6. ESP32ని ఉపయోగించి మైక్రో SD కార్డ్‌లో వివిధ విధులను నిర్వర్తించడం
- 6.1 మైక్రో SD కార్డ్‌లో డైరెక్టరీలను సృష్టిస్తోంది
- 6.2 మైక్రో SD కార్డ్‌లో డైరెక్టరీలను జాబితా చేయడం
- 6.3 డైరెక్టరీలను తొలగిస్తోంది
- 6.4 మైక్రో SD కార్డ్ రకాన్ని పొందండి
- 6.5 SD కార్డ్ పరిమాణాన్ని పొందండి
1. మైక్రో SD కార్డ్ మాడ్యూల్
మైక్రో SD కార్డ్ మాడ్యూల్ అనేది మీ మైక్రోకంట్రోలర్ బోర్డ్‌కి SD కార్డ్‌ని కనెక్ట్ చేయగల ESP32 సెన్సార్. ఇది SPI కమ్యూనికేషన్ ప్రోటోకాల్‌పై పనిచేస్తుంది. ఇది ESP32 లేదా Arduino వంటి ఏదైనా ఇతర మైక్రోకంట్రోలర్ బోర్డుని SPI ప్రోటోకాల్ ద్వారా SD కార్డ్‌లో నిల్వ చేసిన డేటాను యాక్సెస్ చేయడానికి అనుమతిస్తుంది.
SD కార్డ్ మాడ్యూల్ కోసం వర్కింగ్ వోల్టేజ్ 3.3V, కాబట్టి దీన్ని నేరుగా ESP32 లేదా ఏదైనా ఇతర మైక్రోకంట్రోలర్ బోర్డుకి కనెక్ట్ చేయడం సాధ్యం కాదు. దాని కోసం, మేము 5V కంటే ఎక్కువ పని చేసే SD కార్డ్ మాడ్యూల్ లేదా సెన్సార్‌ని ఉపయోగించాలి.
1.1 పిన్అవుట్
మైక్రో SD కార్డ్ మొత్తం ఆరు పిన్‌లను కలిగి ఉంటుంది. వాటిలో రెండు పవర్ పిన్స్: VCC మరియు GND. SPI కమ్యూనికేషన్ ప్రోటోకాల్ కోసం రీడింగ్ నాలుగు పిన్‌లు ఉపయోగించబడతాయి. ఈ మొత్తం ఆరు పిన్‌ల వివరాలు క్రింది విధంగా ఉన్నాయి:
పవర్ పిన్స్:
- VCC: ESP32 5V పిన్‌కి కనెక్ట్ అవుతుంది.
- GND: ESP32 గ్రౌండ్ (GND) పిన్‌కి కనెక్ట్ అవుతుంది.
SPI పిన్స్:
- MISO: (మాస్టర్ ఇన్ స్లేవ్ అవుట్) ESP32 MOSI (Master Out Slave In) పిన్‌కి కనెక్ట్ అవుతుంది.
- పొగ: ESP32 MISO (మాస్టర్ ఇన్ స్లేవ్ అవుట్) పిన్‌కి కనెక్ట్ అవుతుంది.
- SCK: ESP32 SCK (సీరియల్ క్లాక్) పిన్‌కి కనెక్ట్ అవుతుంది.
- SS: (స్లేవ్ సెలెక్ట్) Arduino కోడ్‌లో పేర్కొన్న పిన్‌కి SS (స్లేవ్ సెలెక్ట్) పిన్‌గా కనెక్ట్ అవుతుంది.
2. మైక్రో SD కార్డ్ మాడ్యూల్‌తో ESP32ని ఎలా ఇంటర్‌ఫేస్ చేయాలి
మైక్రో SD కార్డ్ మాడ్యూల్‌తో ESP32ని ఇంటర్‌ఫేస్ చేయడానికి, మీరు మీ SD కార్డ్ సెన్సార్ కోసం పవర్ పిన్‌లను సెటప్ చేయాలి. తదుపరి SPI పిన్‌లను సెటప్ చేయండి. ఇక్కడ మీకు రెండు ఎంపికలు ఉన్నాయి, మీరు డిఫాల్ట్ SPI పిన్‌లను సెట్ చేయవచ్చు లేదా మీ స్వంత కస్టమ్ SPI పిన్‌లను నిర్వచించవచ్చు.
డిఫాల్ట్ SPI పిన్‌లను ఉపయోగిస్తున్నప్పుడు, మేము జోడించబోతున్నాము SD హెచ్ మరియు SD_MMC.h గ్రంథాలయాలు. డిఫాల్ట్‌గా, ఈ లైబ్రరీలు SPI కమ్యూనికేషన్ కోసం VSPI SPI పిన్‌లను (23, 19, 18, 5) తీసుకుంటాయి. అయితే, మీరు SPI కమ్యూనికేషన్ కోసం ఇతర పిన్‌లను కూడా సెట్ చేయవచ్చు.
ESP32 రెండు SPI ఇంటర్‌ఫేస్‌లను HSPI మరియు VSPIలను కలిగి ఉంది, వాటి పిన్స్ వివరాలతో ఈ క్రింది విధంగా ఉన్నాయి:
| SPI | పొగ | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
సంబంధిత: ESP32 పిన్అవుట్ సూచన - పూర్తి గైడ్
2.2 SD కార్డ్‌ని సిద్ధం చేసుకోండి
తర్వాత, మీరు మైక్రో SD కార్డ్‌కి డేటాను చదవడం మరియు వ్రాయడం కొనసాగించడానికి ముందు, ముందుగా, మీరు ముందుగా ఏదైనా మునుపటి డేటాను ఫార్మాట్ చేయడం ద్వారా దాన్ని సెటప్ చేయాలి.
ఏదైనా కార్డ్ రీడర్ ఉపయోగించి మీ SD కార్డ్‌ని తెరవండి మరియు ఫార్మాట్ అది.
మీ కార్డ్ ఫైల్ సిస్టమ్ కోసం FAT32ని ఎంచుకుని, క్లిక్ చేయండి ప్రారంభించండి .
కార్డ్‌ని ఫార్మాట్ చేసిన తర్వాత, ఎంచుకోండి అలాగే .
ఇప్పుడు మీ SD కార్డ్ SD కార్డ్ మాడ్యూల్‌ని ఉపయోగించి ESP32తో ఇంటర్‌ఫేస్ చేయడానికి సిద్ధంగా ఉంది.
2.3 బొమ్మ నమునా
మైక్రో SD కార్డ్ సెన్సార్‌ను ESP32తో కనెక్ట్ చేయడానికి, దిగువ ఇచ్చిన కాన్ఫిగరేషన్‌ను అనుసరించండి:
కనెక్షన్ వైర్ యొక్క పిన్ కాన్ఫిగరేషన్ కోసం క్రింది పట్టిక ఉంది:
| మైక్రో SD కార్డ్ | ESP32 |
| GND | GND |
| VCC | రండి |
| CS | D5 |
| పొగ | D23 |
| SCK | D18 |
| MISO | D19 |
3. హార్డ్వేర్
హార్డ్వేర్ కోసం, మీకు ESP32 మరియు SD కార్డ్ మాడ్యూల్‌తో పాటు కొన్ని జంపర్ వైర్లు బ్రెడ్‌బోర్డ్ అవసరం.
4. కోడ్
ఇప్పుడు మేము మైక్రో SD కార్డ్ లోపల టెక్స్ట్ ఫైల్‌ను సృష్టించే కోడ్‌ను వ్రాస్తాము మరియు దాని తర్వాత, అది దానికి కొంత టెక్స్ట్ స్ట్రింగ్‌ను వ్రాస్తుంది. పూర్తయిన తర్వాత, మేము Arduino IDE సీరియల్ మానిటర్‌లో టెక్స్ట్ ఫైల్ యొక్క కంటెంట్‌ను చదువుతాము.
Arduino IDEని ప్రారంభించండి మరియు ఇచ్చిన కోడ్‌ను కంపైల్ చేయండి. ఆ తర్వాత దానిని మీ ESP32 బోర్డుకు బర్న్ చేయండి:
##
ఫైల్ myFile ;
స్థిరంగా int CS = 5 ;
// ఇచ్చిన సందేశాన్ని పేర్కొన్న మార్గంలో ఫైల్‌కి వ్రాయండి
శూన్యం రైట్ ఫైల్ ( స్థిరంగా చార్ * మార్గం , స్థిరంగా చార్ * సందేశం ) {
// ఫైల్‌ను తెరవండి. ఇది ఒకేసారి తెరవడానికి ఒక ఫైల్‌కు మద్దతు ఇస్తుంది
// కొత్త ఫైల్‌ను తెరవడానికి ముందు ఇతర ఫైల్‌ను మూసివేయండి
myFile = SD. తెరవండి ( మార్గం , FILE_WRITE ) ;
ఉంటే ( myFile ) {
క్రమ. printf ( '%sకి వ్రాయడం' , మార్గం ) ;
myFile. println ( సందేశం ) ;
myFile. దగ్గరగా ( ) ; // ఫైల్‌ను మూసివేయండి
క్రమ. println ( 'పూర్తయింది.' ) ;
} లేకపోతే {
క్రమ. println ( 'ఫైల్ తెరవడంలో లోపం' ) ;
క్రమ. println ( మార్గం ) ;
}
}
// పేర్కొన్న మార్గంలో ఫైల్ కంటెంట్‌ను ముద్రించండి
శూన్యం రీడ్ ఫైల్ ( స్థిరంగా చార్ * మార్గం ) {
// ఫైలును తెరవండి
myFile = SD. తెరవండి ( మార్గం ) ;
ఉంటే ( myFile ) {
క్రమ. printf ( '%s నుండి ఫైల్ చదువుతోంది \n ' , మార్గం ) ;
// చివరి వరకు పూర్తి ఫైల్‌ను చదవండి
అయితే ( myFile. అందుబాటులో ( ) ) {
క్రమ. వ్రాయడానికి ( myFile. చదవండి ( ) ) ;
}
myFile. దగ్గరగా ( ) ; // ఫైల్‌ను మూసివేయండి
} లేకపోతే {
// ఫైల్ తెరవడంలో విఫలమైతే, లోపాన్ని ముద్రించండి:
క్రమ. println ( 'text తెరవడంలో లోపం' ) ;
}
}
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 9600 ) ;
ఆలస్యం ( 500 ) ;
అయితే ( ! క్రమ ) { ; }
క్రమ. println ( 'SD కార్డ్‌ని ప్రారంభిస్తోంది...' ) ;
ఉంటే ( ! SD. ప్రారంభం ( CS ) ) {
క్రమ. println ( 'ప్రారంభం విఫలమైంది!' ) ;
తిరిగి ;
}
క్రమ. println ( 'ప్రారంభం పూర్తయింది.' ) ;
రైట్ ఫైల్ ( '/test.txt' , 'Linuxhint.com' ) ;
రీడ్ ఫైల్ ( '/test.txt' ) ;
}
శూన్యం లూప్ ( ) {
}
4.1 కోడ్ వివరణ
మంచి అవగాహన కోసం, మేము ఈ కోడ్‌ను ఉపభాగాలుగా విభజిస్తాము.
ప్రారంభించడం మరియు సెటప్: ముందుగా, SD కార్డ్ మాడ్యూల్‌కు సంబంధించిన కొన్ని ముఖ్యమైన లైబ్రరీలను చేర్చడం ద్వారా కోడ్ ప్రారంభించబడింది. SD కార్డ్‌తో కమ్యూనికేషన్ కోసం SPI.h లైబ్రరీ మరియు SD కార్డ్ కార్యకలాపాలను నిర్వహించడానికి SD.h జోడించబడ్డాయి. తరువాత, ఇది గ్లోబల్ వేరియబుల్‌ను నిర్వచిస్తుంది myFile ఫైల్ కార్యకలాపాలను నిర్వహించడానికి ఫైల్ రకం. CS స్థిరాంకం పిన్ 5కి సెట్ చేయబడింది, ఇది SD కార్డ్ కోసం చిప్ సెలెక్ట్ (CS) పిన్‌గా ఉపయోగించబడుతుంది.
సెటప్() ఫంక్షన్: సెటప్ ఫంక్షన్ లోపల, సీరియల్ కమ్యూనికేషన్ ప్రారంభించబడింది. ఆ తర్వాత, మేము SD.begin(CS) ఫంక్షన్‌ని ఉపయోగించి SD కార్డ్ మాడ్యూల్‌ని ప్రారంభించాము. ఇంకా, మేము టెక్స్ట్ ఫైల్‌కి వచనాన్ని చదవడం మరియు వ్రాయడం కోసం రెండు వేర్వేరు విధులను కూడా నిర్వచించాము.
SD కార్డ్‌కి వ్రాయడం: WriteFile() ఫంక్షన్ SD.open(path, FILE_WRITE)ని ఉపయోగించి వ్రాయడానికి test.txt ఫైల్‌ను తెరుస్తుంది. ఆ తర్వాత, ఇది myFile.println(సందేశం)ని ఉపయోగించి ఫైల్‌కి Linuxhint.com స్ట్రింగ్‌ను వ్రాస్తుంది.
SD కార్డ్ నుండి చదవడం: ఫైల్ కంటెంట్‌ను చదవడానికి, మేము ReadFile() ఫంక్షన్‌ని ఉపయోగించాము. విజయవంతంగా చదివితే, డేటా Arduino సీరియల్ పోర్ట్‌కి పంపబడుతుంది మరియు Arduino IDE సీరియల్ మానిటర్‌లో ప్రదర్శించబడుతుంది.
5. అవుట్పుట్
అవుట్‌పుట్‌లో, Arduino IDE కోడ్ లోపల మేము నిర్వచించిన అదే స్ట్రింగ్ మీ Arduino IDE సీరియల్ మానిటర్‌లో ప్రదర్శించబడడాన్ని మీరు చూడవచ్చు.
6. ESP32ని ఉపయోగించి మైక్రో SD కార్డ్‌లో వివిధ విధులను నిర్వర్తించడం
మేము నేరుగా Arduino IDE కోడ్ ద్వారా మైక్రో SD కార్డ్‌లలో డైరెక్టరీలను సృష్టించడం, తీసివేయడం లేదా జోడించడం వంటి వివిధ కార్యకలాపాలను చేయవచ్చు.
6.1 మైక్రో SD కార్డ్‌లో డైరెక్టరీలను సృష్టిస్తోంది
దిగువ కోడ్ మైక్రో SD కార్డ్ లోపల కొత్త డైరెక్టరీని సృష్టిస్తుంది. ఇది అనే ఫంక్షన్‌ని నిర్వచిస్తుంది సృష్టించుDir అది ఫైల్ సిస్టమ్ ఆబ్జెక్ట్ (fs::FS) మరియు ఇన్‌పుట్‌గా మార్గాన్ని తీసుకుంటుంది. ఈ ఫంక్షన్ పేర్కొన్న మార్గంతో డైరెక్టరీని సృష్టించడానికి ప్రయత్నిస్తుంది మరియు విజయం లేదా వైఫల్యాన్ని సూచించే సందేశాలను ముద్రిస్తుంది.
#'FS.h'ని చేర్చండి#'SD.h'ని చేర్చండి
#'SPI.h'ని చేర్చండి
శూన్యం సృష్టించుDir ( fs :: FS & fs , స్థిరంగా చార్ * మార్గం ) {
క్రమ. printf ( 'Dir సృష్టిస్తోంది: %s \n ' , మార్గం ) ;
ఉంటే ( fs. mkdir ( మార్గం ) ) {
క్రమ. println ( 'దిర్ సృష్టించబడింది' ) ;
} లేకపోతే {
క్రమ. println ( 'mkdir విఫలమైంది' ) ;
}
}
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 115200 ) ;
// SD కార్డ్‌ని ప్రారంభించండి
ఉంటే ( ! SD. ప్రారంభం ( ) ) {
క్రమ. println ( 'కార్డ్ మౌంట్ విఫలమైంది' ) ;
తిరిగి ;
}
// 'mydir' పేరుతో డైరెక్టరీని సృష్టించండి
సృష్టించుDir ( SD , '/ మైడిర్' ) ;
}
శూన్యం లూప్ ( ) {
}
అవుట్‌పుట్‌లో, కొత్త డైరెక్టరీతో సృష్టించబడినట్లు మీరు చూడవచ్చు / మైడిర్ పేరు.
6.2 మైక్రో SD కార్డ్‌లో డైరెక్టరీలను జాబితా చేయడం
దిగువ కోడ్‌లో, మేము మైక్రో SD కార్డ్‌లో ఉన్న అన్ని డైరెక్టరీలను జాబితా చేయబోతున్నాము. ది జాబితాDir ఫంక్షన్ SD కార్డ్‌లోని డైరెక్టరీ యొక్క కంటెంట్‌లను పునరావృతంగా జాబితా చేస్తుంది. ఇది రెండు డైరెక్టరీల గురించిన సమాచారాన్ని (“DIR”తో ప్రిఫిక్స్ చేయబడింది) మరియు ఫైల్‌లు (“FILE”తో ప్రిఫిక్స్ చేయబడింది) వాటి పేర్లు మరియు పరిమాణాలతో సహా ప్రింట్ చేస్తుంది.
#'FS.h'ని చేర్చండి#'SD.h'ని చేర్చండి
#'SPI.h'ని చేర్చండి
శూన్యం జాబితాDir ( fs :: FS & fs , స్థిరంగా చార్ * పేరు , uint8_t స్థాయిలు ) {
క్రమ. printf ( 'జాబితా డైరెక్టరీ: %s \n ' , పేరు ) ;
ఫైల్ రూట్ = fs. తెరవండి ( పేరు ) ;
ఉంటే ( ! రూట్ ) {
క్రమ. println ( 'డైరెక్టరీని తెరవడంలో విఫలమైంది' ) ;
తిరిగి ;
}
ఉంటే ( ! రూట్. డైరెక్టరీ ( ) ) {
క్రమ. println ( 'డైరెక్టరీ కాదు' ) ;
తిరిగి ;
}
ఫైల్ ఫైల్ = రూట్. openNextFile ( ) ;
అయితే ( ఫైల్ ) {
ఉంటే ( ఫైల్. డైరెక్టరీ ( ) ) {
క్రమ. ముద్రణ ( 'మీరు:' ) ;
క్రమ. println ( ఫైల్. పేరు ( ) ) ;
ఉంటే ( స్థాయిలు ) {
జాబితాDir ( fs , ఫైల్. పేరు ( ) , స్థాయిలు - 1 ) ;
}
} లేకపోతే {
క్రమ. ముద్రణ ( 'ఫైల్:' ) ;
క్రమ. ముద్రణ ( ఫైల్. పేరు ( ) ) ;
క్రమ. ముద్రణ ( 'పరిమాణం:' ) ;
క్రమ. println ( ఫైల్. పరిమాణం ( ) ) ;
}
ఫైల్ = రూట్. openNextFile ( ) ;
}
}
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 115200 ) ;
ఉంటే ( ! SD. ప్రారంభం ( ) ) {
క్రమ. println ( 'కార్డ్ మౌంట్ విఫలమైంది' ) ;
తిరిగి ;
}
జాబితాDir ( SD , '/' , 0 ) ;
}
శూన్యం లూప్ ( ) {
}
అవుట్‌పుట్‌లో, మీరు రెండు వేర్వేరు ఫైల్‌లను చూడవచ్చు. ఒకటి టెక్స్ట్ ఫైల్ మరియు మరొకటి మనం మునుపటి కోడ్‌లో సృష్టించిన డైరెక్టరీ.
6.3 డైరెక్టరీలను తొలగిస్తోంది
ఇప్పుడు మనం గతంలో సృష్టించిన డైరెక్టరీలు మరియు టెక్స్ట్ ఫైల్‌లను తీసివేస్తాము. దాని కోసం మేము ఉపయోగించబోతున్నాము తొలగించుDir ఫంక్షన్, ఇది మార్గం ద్వారా పేర్కొన్న డైరెక్టరీని తీసివేయడానికి ప్రయత్నిస్తుంది. విజయవంతమైతే, అది ముద్రిస్తుంది Dir తొలగించబడింది ; లేకపోతే, అది ముద్రిస్తుంది rmdir విఫలమైంది .
#'FS.h'ని చేర్చండి#'SD.h'ని చేర్చండి
#'SPI.h'ని చేర్చండి
శూన్యం తొలగించుDir ( fs :: FS & fs , స్థిరంగా చార్ * మార్గం ) {
క్రమ. printf ( 'Dir తీసివేస్తోంది: %s \n ' , మార్గం ) ;
ఉంటే ( fs. rm ఉంది ( మార్గం ) ) {
క్రమ. println ( 'దిర్ తొలగించబడింది' ) ;
} లేకపోతే {
క్రమ. println ( 'rmdir విఫలమైంది' ) ;
}
}
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 115200 ) ;
ఉంటే ( ! SD. ప్రారంభం ( ) ) {
క్రమ. println ( 'కార్డ్ మౌంట్ విఫలమైంది' ) ;
తిరిగి ;
}
}
శూన్యం లూప్ ( ) {
}
6.4 మైక్రో SD కార్డ్ రకాన్ని పొందండి
మైక్రో SD కార్డ్ లేదా ఎస్ నయం డి igital కార్డ్ వాస్తవానికి SD కార్డ్ అసోసియేషన్ ద్వారా రూపొందించబడింది మరియు స్మార్ట్‌ఫోన్‌లు మరియు కెమెరాల వంటి పోర్టబుల్ పరికరాలలో ఉపయోగం కోసం రూపొందించబడింది. SD కార్డ్‌లు ప్రధానంగా నాలుగు రకాల కుటుంబాలను కలిగి ఉంటాయి:
- SDSC (స్టాండర్డ్ కెపాసిటీ SD): ఈ కార్డ్‌లు నిరాడంబరమైన 2GB నిల్వ సామర్థ్యాన్ని అందిస్తాయి మరియు FAT-12 మరియు FAT-16 ఫైల్ సిస్టమ్‌లను ఉపయోగిస్తాయి.
- SDHC (హై కెపాసిటీ SD): ఈ కార్డ్‌లు 2GB నుండి 32GB వరకు ఉంటాయి మరియు FAT-32 ఫైల్ సిస్టమ్‌ను ఉపయోగిస్తాయి.
- SDXC (ఎక్స్‌టెండెడ్ కెపాసిటీ SD): ఈ కార్డ్‌లు exFAT ఫైల్ సిస్టమ్‌ను ఉపయోగిస్తాయి మరియు 32GB నుండి 2TB వరకు ప్రారంభమవుతాయి.
- SDIO: SDIO కార్డ్‌లు డేటా నిల్వను INPUT/OUTPUT ఫంక్షన్‌లతో కలపడం ద్వారా ద్వంద్వ ప్రయోజనాన్ని అందిస్తాయి.
మీ కార్డ్ రకాన్ని తనిఖీ చేయడానికి, క్రింది కోడ్‌ను అమలు చేయండి:
#'FS.h'ని చేర్చండి#'SD.h'ని చేర్చండి
#'SPI.h'ని చేర్చండి
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 115200 ) ;
ఉంటే ( ! SD. ప్రారంభం ( ) ) {
క్రమ. println ( 'కార్డ్ మౌంట్ విఫలమైంది' ) ;
తిరిగి ;
}
uint8_t కార్డు రకము = SD. కార్డు రకము ( ) ;
ఉంటే ( కార్డు రకము == CARD_NONE ) {
క్రమ. println ( 'SD కార్డ్ జోడించబడలేదు' ) ;
తిరిగి ;
}
క్రమ. ముద్రణ ( 'SD కార్డ్ రకం:' ) ;
ఉంటే ( కార్డు రకము == CARD_MMC ) {
క్రమ. println ( 'MMC' ) ;
} లేకపోతే ఉంటే ( కార్డు రకము == CARD_SD ) {
క్రమ. println ( 'SDSC' ) ;
} లేకపోతే ఉంటే ( కార్డు రకము == CARD_SDHC ) {
క్రమ. println ( 'SDHC' ) ;
} లేకపోతే {
క్రమ. println ( 'తెలియని' ) ;
}
uint64_t కార్డు పరిమాణం = SD. కార్డు పరిమాణం ( ) / ( 1024 * 1024 ) ;
క్రమ. printf ( 'SD కార్డ్ పరిమాణం: %lluMB \n ' , కార్డు పరిమాణం ) ;
}
శూన్యం లూప్ ( ) {
}
నా దగ్గర 32GB కార్డ్ ఉన్నందున, అది రేంజ్‌లో ఉన్నట్లు మీరు చూడవచ్చు SDHC కార్డులు.
6.5 మైక్రో SD కార్డ్ పరిమాణాన్ని పొందండి
దిగువ కోడ్‌ను మీ ESP32 బోర్డుకి అప్‌లోడ్ చేయడం ద్వారా మీరు SD కార్డ్ పరిమాణాన్ని కూడా పొందవచ్చు.
#'FS.h'ని చేర్చండి#'SD.h'ని చేర్చండి
#'SPI.h'ని చేర్చండి
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 115200 ) ;
ఉంటే ( ! SD. ప్రారంభం ( ) ) {
క్రమ. println ( 'కార్డ్ మౌంట్ విఫలమైంది' ) ;
తిరిగి ;
}
uint8_t కార్డు రకము = SD. కార్డు రకము ( ) ;
ఉంటే ( కార్డు రకము == CARD_NONE ) {
క్రమ. println ( 'SD కార్డ్ జోడించబడలేదు' ) ;
తిరిగి ;
}
uint64_t కార్డు పరిమాణం = SD. కార్డు పరిమాణం ( ) / ( 1024 * 1024 ) ;
క్రమ. printf ( 'SD కార్డ్ పరిమాణం: %lluMB \n ' , కార్డు పరిమాణం ) ;
// ఇతర విధులు (listDir, createDir, removeDir, మొదలైనవి) ఇక్కడ కాల్ చేయవచ్చు
}
శూన్యం లూప్ ( ) {
}
అవుట్పుట్ నుండి, నేను సుమారు 30GB SD కార్డ్‌ని కలిగి ఉన్నట్లు మీరు చూడవచ్చు.
ముగింపు
ESP32 బోర్డుని ఉపయోగించి SD కార్డ్ నుండి డేటాను చదవడానికి మరియు వ్రాయడానికి మైక్రో SD కార్డ్ మాడ్యూల్ ఉపయోగించబడుతుంది. మైక్రో SD కార్డ్ మాడ్యూల్ SPI ఇంటర్‌ఫేస్‌ని ఉపయోగించి మైక్రోకంట్రోలర్‌తో కమ్యూనికేట్ చేస్తుంది. కాబట్టి మీరు SPI లైబ్రరీని ఉపయోగించవచ్చు లేదా కోడ్ లోపల మీ స్వంత SPI పిన్‌లను నిర్వచించవచ్చు. కనెక్ట్ అయిన తర్వాత, మీరు టెక్స్ట్ ఫైల్‌ను వ్రాయడాన్ని చదవవచ్చు లేదా మీ SD కార్డ్‌లో కొత్త డైరెక్టరీలను సృష్టించవచ్చు.