ఈ రైటప్ Serial.readBytesUntil() ఫంక్షన్‌ని లోతుగా కంపైల్ చేస్తుంది. మేము అది ఏమిటి, ఇది ఎలా పని చేస్తుంది మరియు Arduino కోడ్‌లో ఎలా ఉపయోగించాలో వివరించే Arduino కోడ్‌ను కవర్ చేస్తాము.
Serial.readBytesUntil()
Serial.readBytesUntil() ఫంక్షన్ Arduino సీరియల్ క్లాస్‌లో ఒక భాగం. ఈ ఫంక్షన్ నిర్దిష్ట అక్షరాన్ని లేదా గరిష్ట సంఖ్యలో బైట్‌లను కనుగొనే వరకు స్ట్రీమ్ నుండి డేటాను రీడ్ చేస్తుంది. అక్షరం లేదా గరిష్ట సంఖ్యలో బైట్లు కనుగొనబడిన తర్వాత, ఫంక్షన్ చదవడం ఆపివేస్తుంది మరియు అది చదివిన డేటాను అందిస్తుంది.
కింది షరతులు నెరవేరినప్పుడల్లా Serial.readBytesUntil() ఫంక్షన్ ముగుస్తుంది:
- ఫంక్షన్ టెర్మినేటర్ అక్షరాన్ని గుర్తించినప్పుడు
- నిర్వచించిన బఫర్ పొడవు చేరుకుంది
- సెట్ చేసిన సమయం ముగిసింది లేదా సమయం ముగిసింది
ఈ ఫంక్షన్ టెర్మినేటర్ అక్షరాన్ని తిరిగి ఇవ్వదు, ఇది టెర్మినేటర్‌కు ముందు ఉన్న చివరి అక్షరం వరకు మాత్రమే డేటాను అందిస్తుంది. ఈ ఫంక్షన్ ద్వారా 0 తిరిగి వచ్చినప్పుడు చెల్లుబాటు అయ్యే డేటా కనుగొనబడలేదు.
వాక్యనిర్మాణం
Serial.readBytesUntil() ఫంక్షన్ కింది వాక్యనిర్మాణాన్ని కలిగి ఉంది:
క్రమ. చదవండి బైట్లు వరకు ( చార్ టెర్మినేటర్, చార్ * బఫర్, పరిమాణం_t పొడవు ) ;
పారామితులు
Serial.readBytesUntil() ఫంక్షన్ యొక్క పారామితులు క్రింది విధంగా ఉన్నాయి:
- టెర్మినేటర్ పాత్ర: ఫంక్షన్ చదవడం ఆగిపోయే పాత్ర.
- బఫర్: బఫర్‌లో రీడ్ సీరియల్ డేటా అనుమతించబడిన డేటా రకం చార్ లేదా బైట్ యొక్క శ్రేణి.
- పొడవు: చదవడానికి గరిష్ట సంఖ్యలో బైట్లు. అనుమతించబడిన డేటా రకం int .
తిరిగి
బఫర్‌లో ఉంచబడిన బైట్‌ల సంఖ్య.
గమనికలు: రిటర్న్ డేటాలో టెర్మినేటర్ క్యారెక్టర్ డేటా స్ట్రీమ్ నుండి Serial.readBytesUntil() ఫంక్షన్ ద్వారా విస్మరించబడుతుంది.
ఉదాహరణ Arduino కోడ్
Arduino కోడ్‌ని అనుసరించి దాని వినియోగాన్ని వివరిస్తుంది Serial.readBytesUntil() ఫంక్షన్:
శూన్యం సెటప్ ( ) {క్రమ. ప్రారంభం ( 9600 ) ; // 9600 బాడ్ రేటుతో సీరియల్ కనెక్షన్‌ని ప్రారంభించండి
}
శూన్యం లూప్ ( ) {
బైట్ బఫర్ [ 5 ] ; // ఇన్‌కమింగ్ డేటాను నిల్వ చేయడానికి బైట్ శ్రేణిని నిర్వచించండి
int numBytes = క్రమ. చదవండి బైట్లు వరకు ( ' \n ' , బఫర్, 5 ) ; // కొత్త లైన్ అక్షరం ఎదురయ్యే వరకు సీరియల్ కనెక్షన్ నుండి ఇన్‌కమింగ్ డేటాను చదవండి
ఉంటే ( numBytes > 0 ) { // ఏవైనా బైట్లు చదవబడ్డాయో లేదో తనిఖీ చేయండి
క్రమ. ముద్రణ ( 'అందుకున్న పాత్ర:' ) ;
క్రమ. వ్రాయడానికి ( బఫర్, numBytes ) ; // అందుకున్న డేటాను సీరియల్ మానిటర్‌కు ప్రింట్ చేయండి
క్రమ. println ( ) ;
}
}
సెటప్() ఫంక్షన్‌లో బాడ్ రేట్ సీరియల్ కమ్యూనికేషన్‌ను ఏర్పాటు చేస్తుంది.
లూప్() ఫంక్షన్‌లో, మనం మొదటగా పిలువబడే బైట్ శ్రేణిని నిర్వచించాము 'బఫర్' . సీరియల్ కనెక్షన్ నుండి చదివిన ఇన్‌కమింగ్ డేటాను నిల్వ చేయడానికి ఈ శ్రేణి ఉపయోగించబడుతుంది.
తరువాత, మేము కాల్ చేస్తాము Serial.readBytesUntil() ఫంక్షన్, ఇది కొత్త లైన్ అక్షరాన్ని ('\n') ఎదుర్కొనే వరకు సీరియల్ కనెక్షన్ నుండి ఇన్‌కమింగ్ డేటాను రీడ్ చేస్తుంది. తదుపరి ఆర్గ్యుమెంట్ అనేది బఫర్ యొక్క పొడవు, ఇది ఒకేసారి గరిష్టంగా 5 బైట్‌ల డేటాను తీసుకుంటుంది.
తిరిగి వచ్చిన బైట్ లో నిల్వ చేయబడుతుంది 'numBytes' వేరియబుల్. ఒకవేళ అందుకున్న డేటా బఫర్ పొడవు కంటే ఎక్కువగా ఉంటే, డేటా నిలిపివేయబడుతుంది మరియు తదుపరి డేటా స్ట్రీమ్‌లో పంపబడుతుంది.
అవుట్‌పుట్
ముగింపు
ది Serial.readBytesUntil() Arduino ప్రోగ్రామింగ్‌లోని ఫంక్షన్ పేర్కొన్న టెర్మినేటర్ అక్షరాన్ని స్వీకరించే వరకు సీరియల్ ఇన్‌పుట్ స్ట్రీమ్ నుండి బైట్‌లను రీడ్ చేస్తుంది. ఫంక్షన్ మొత్తం బైట్‌లను రీడ్ చేస్తుంది మరియు వాటిని అందించిన బఫర్‌లో నిల్వ చేస్తుంది. Serial.readBytesUntil() ఫంక్షన్‌కి సంబంధించిన మరింత సమాచారాన్ని పొందడానికి కథనాన్ని చదవండి.