Arduino అనేది ఎలక్ట్రానిక్ ప్లాట్‌ఫారమ్, ఇది స్కెచ్ అని పిలువబడే కోడ్ రూపంలో వినియోగదారుల నుండి సూచనలను తీసుకుంటుంది మరియు తదనుగుణంగా అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది. సూచనలను సేకరించి, వాటిని ఒక్కొక్కటిగా ప్రాసెస్ చేయడానికి, Arduino సీరియల్ బఫర్‌ను ఉపయోగిస్తుంది. ఆర్డునో సీరియల్ బఫర్ ఇన్‌కమింగ్ డేటాను ప్రాసెస్ చేయడానికి పరికరం సిద్ధంగా ఉండే వరకు వాటిని కలిగి ఉంటుంది. ఇన్‌కమింగ్ డేటాతో జోక్యాన్ని నివారించడానికి కొన్నిసార్లు మేము Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయాలి. దీన్ని మరింత వివరంగా చూద్దాం.
Arduino సీరియల్ బఫర్
కాబట్టి, USART అని పిలువబడే సీరియల్ కమ్యూనికేషన్ ప్రోటోకాల్‌ను ఉపయోగించి Arduino కమ్యూనికేట్ చేస్తుందని మనందరికీ తెలుసు. అవును, Arduino SPI, I2C వంటి కొన్ని ఇతర ప్రోటోకాల్‌లను కలిగి ఉంది కానీ USART అనేది సర్వసాధారణమైన మరియు తరచుగా ఉపయోగించే ప్రోటోకాల్. Arduino మూడు ప్రోటోకాల్‌లను చదవడానికి మీకు ఆసక్తి ఉంటే, క్లిక్ చేయండి ఇక్కడ .
Arduino సీరియల్ బఫర్‌లు ఇన్‌కమింగ్ సీరియల్ క్యారెక్టర్‌లను సేకరిస్తాయి మరియు మైక్రోకంట్రోలర్ వాటిని ప్రాసెస్ చేసే వరకు వాటిని ఉంచుతాయి. సీరియల్ కమ్యూనికేషన్ అనేది ఒక పరికరం నుండి మరొక పరికరంకి డేటాను బదిలీ చేసే పద్ధతి. Arduino దాని బోర్డులపై USART హార్డ్‌వేర్‌ని ఉపయోగించి ప్రతి 8 బిట్‌లను బైట్‌గా సమీకరించింది. అప్పుడు ఈ బైట్‌లను సీరియల్ బఫర్‌లో నిల్వ చేయండి, గరిష్టంగా 64 బైట్‌లను Arduino సీరియల్ బఫర్‌లో నిల్వ చేయవచ్చు.
Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయండి
మెమరీ ఓవర్‌ఫ్లో లేదా సీరియల్ పిన్ వద్ద పెద్ద మొత్తంలో డేటా ఉన్నట్లయితే, ఇన్‌కమింగ్ డేటాను నిల్వ చేయడానికి మేము ముందుగా సీరియల్ బఫర్‌ను క్లియర్ చేయాలి. Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయడానికి సాధ్యమయ్యే మార్గాలను తెలుసుకుందాం.
Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయడానికి మార్గాలు
సీరియల్ బఫర్ స్పేస్‌ను ఖాళీ చేయడానికి, కొత్త డేటాతో అప్‌డేట్ చేయడానికి రెండు మార్గాలను అనుసరించడం సహాయకరంగా ఉంటుంది:
-
- Serial.flush() ఫంక్షన్‌ని ఉపయోగించి సీరియల్ బఫర్‌ని క్లియర్ చేయండి
- Serial.begin() ఫంక్షన్‌ని ఉపయోగించి సీరియల్ బఫర్‌ని క్లియర్ చేయండి
1: Serial.flush() ఫంక్షన్‌ని ఉపయోగించి సీరియల్ బఫర్‌ని క్లియర్ చేయండి
కాబట్టి, Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయగల మొదటి పద్ధతి Serial.flush() ఫంక్షన్‌ని ఉపయోగించడం. ఈ ఫంక్షన్ Arduino సీరియల్ లైబ్రరీ ఫంక్షన్‌కు చెందినది.
Serial.flush()
Arduino Serial.flush() ఫంక్షన్ డేటా పూర్తిగా ప్రసారం అయ్యే వరకు వేచి ఉంటుంది. ఇన్‌కమింగ్ డేటాను విస్మరించే బదులు, బఫర్‌లోని డేటా పూర్తిగా ప్రసారం చేయబడిన తర్వాత సీరియల్ బఫర్ కొత్త డేటాను స్వీకరించడానికి వేచి ఉండటానికి అనుమతిస్తుంది.
గమనిక : Serial.flush() ప్రోగ్రామ్‌లను ఉపయోగించిన తర్వాత సీరియల్ మానిటర్‌లో అవుట్‌పుట్‌ని అమలు చేయడానికి మరియు ప్రింట్ చేయడానికి ఎక్కువ సమయం పట్టవచ్చు. ప్రస్తుతానికి, Arduino కోడ్ మొత్తం డేటాను ప్రసారం చేసిన తర్వాత వేచి ఉంటుంది, కనుక ఇది దాని మెమరీలో కొత్త డేటాను నిల్వ చేయగలదు.
వాక్యనిర్మాణం
సీరియల్.ఫ్లష్ ( )
పారామితులు
ఇది ఒక పరామితిని మాత్రమే తీసుకుంటుంది.
క్రమ: సీరియల్ పోర్ట్ వస్తువు
తిరిగి వస్తుంది
ఈ ఫంక్షన్ ఏమీ తిరిగి ఇవ్వదు.
ఉదాహరణ కోడ్
Serial.flush() ఫంక్షన్‌ని ఉపయోగించకుండా వ్రాయబడిన కోడ్ ఇక్కడ ఉంది:
శూన్యమైన సెటప్ ( ) {సీరియల్.ప్రారంభం ( 9600 ) ;
సంతకం చేయని పొడవైన millis_FlushStart = మిల్లీస్ ( ) ; /* ప్రస్తుత Arduino గడియారాన్ని సేవ్ చేయడం ద్వారా కోడ్‌ను ప్రారంభించండి సమయం */
Serial.println ( ఎఫ్ ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( ఎఫ్ ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( ఎఫ్ ( 'Linuxhint.com/Tutorial' ) ) ;
సంతకం చేయని పొడవైన millis_FlushStop = మిల్లీస్ ( ) ; /* ప్రస్తుత సమయం ఈ సమయంలో */
సీరియల్.ప్రింట్ ( ఎఫ్ ( 'ఫ్లష్ ఫంక్షన్ లేకుండా ఇది పడుతుంది' ) ) ;
సీరియల్.ప్రింట్ ( millis_FlushStop - millis_FlushStart ) ; /* ప్రింట్లు సమయం డేటాను ప్రింట్ చేయడానికి సీరియల్ బఫర్ ద్వారా తీసుకోబడింది */
Serial.println ( ఎఫ్ ( 'మిల్లీసెకన్లు.' ) ) ;
}
శూన్య లూప్ ( ) {
}
పై కోడ్‌లో మేము మూడు వేర్వేరు స్ట్రింగ్‌లను ప్రారంభించాము మరియు మిల్లీస్() ఫంక్షన్ నుండి ప్రస్తుత సమయాన్ని తీసుకొని కొత్త వేరియబుల్‌లో సేవ్ చేయడం ద్వారా కోడ్‌ను ప్రారంభించాము. మిల్లీస్() ఫంక్షన్‌ని ఉపయోగించి డేటా మళ్లీ ముద్రించబడిన తర్వాత మనం ప్రస్తుత సమయాన్ని కొత్త వేరియబుల్‌కి పాస్ చేస్తాము.
రెండు వేరియబుల్స్ లోపల రెండు సమయాన్ని స్వీకరించిన తర్వాత, మూడు నిర్వచించిన స్ట్రింగ్‌లను మిల్లీసెకన్లలో ప్రింట్ చేయడానికి Arduino తీసుకున్న సమయాన్ని తేడా ఇస్తుంది.
అవుట్‌పుట్ టెర్మినల్‌లో నిర్వచించిన స్ట్రింగ్‌ను ప్రింట్ చేయడానికి 9ms పడుతుందని చూడవచ్చు.
ఇప్పుడు క్రింద ఇవ్వబడిన కోడ్‌లో మేము Serial.flush() ఫంక్షన్‌ని ఉపయోగిస్తాము, ఇది అన్ని స్ట్రింగ్‌లను పాస్ చేయడానికి అనుమతిస్తుంది మరియు తదుపరి డేటాను స్వీకరించడానికి సీరియల్ బఫర్ స్పష్టంగా కనిపించే వరకు వేచి ఉండండి. అందువల్ల, Serial.flush()ని ఉపయోగించకుండా ప్రింటింగ్ డేటాతో పోలిస్తే అదనపు సమయం పడుతుంది.
సీరియల్.ప్రారంభం ( 9600 ) ;
సంతకం చేయని పొడవైన millis_FlushStart = మిల్లీస్ ( ) ; /* ప్రస్తుత Arduino గడియారాన్ని సేవ్ చేయడం ద్వారా కోడ్‌ను ప్రారంభించండి సమయం */
Serial.println ( ఎఫ్ ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( ఎఫ్ ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( ఎఫ్ ( 'Linuxhint.com/Tutorial' ) ) ;
సీరియల్.ఫ్లష్ ( ) ; /* వేచి ఉంది కోసం ఫ్లష్ మెమరీ తర్వాత డేటా బదిలీ చేయబడుతుంది */
సంతకం చేయని పొడవైన millis_FlushStop = మిల్లీస్ ( ) ; /* ప్రస్తుత సమయం ఈ సమయంలో */
సీరియల్.ప్రింట్ ( ఎఫ్ ( 'ఫ్లష్ ఫంక్షన్‌తో ఇది పడుతుంది' ) ) ;
సీరియల్.ప్రింట్ ( millis_FlushStop - millis_FlushStart ) ; /* ప్రింట్లు సమయం డేటాను ప్రింట్ చేయడానికి సీరియల్ బఫర్ ద్వారా తీసుకోబడింది */
Serial.println ( ఎఫ్ ( 'మిల్లీసెకన్లు.' ) ) ;
}
శూన్య లూప్ ( ) {
}
ఈ కోడ్ మేము ఇంతకు ముందు వివరించిన మాదిరిగానే ఉంటుంది. ఇక్కడ వ్యత్యాసం Serial.flush() ఫంక్షన్, ఇది తదుపరి డేటాను స్వీకరించడం కోసం సీరియల్ బఫర్ మెమరీ స్పష్టంగా కనిపించే వరకు ప్రోగ్రామ్ కొంత అదనపు సమయం వరకు వేచి ఉండటానికి అనుమతిస్తుంది.
అవుట్‌పుట్‌లో మనం స్పష్టంగా చూడగలం, ఈసారి మూడు స్ట్రింగ్‌లను ప్రింట్ చేయడానికి 76ms పడుతుంది, ఇది మునుపటి దానితో పోలిస్తే 9ms మాత్రమే పడుతుంది.
2: Serial.begin() ఫంక్షన్‌ని ఉపయోగించి సీరియల్ బఫర్‌ని క్లియర్ చేయండి
ఇప్పటి వరకు మేము సీరియల్ బఫర్‌ను క్లియర్ చేయడానికి Serial.flush() ఫంక్షన్‌ని వివరించాము, కానీ ఈ ఫంక్షన్ డేటా పూర్తిగా ప్రసారం అయ్యే వరకు వేచి ఉండాలి ఇప్పుడు సీరియల్ బఫర్‌లోని ఇన్‌కమింగ్ డేటాను క్లియర్ చేయాలనుకుంటే ఏమి అనే ప్రశ్నలు గుర్తుకు వస్తాయి. ప్రశ్నకు సమాధానం చాలా సులభం: మేము దీన్ని aని ఉపయోగించి చేయవచ్చు అయితే సీరియల్ లైబ్రరీ ఫంక్షన్‌తో లూప్ చేయండి.
వాక్యనిర్మాణం
అయితే ( సీరియల్.అందుబాటులో ఉంది ( ) )
సీరియల్.చదవండి ( ) ;
సీరియల్.ఎండ్ ( ) ;
సీరియల్.ప్రారంభం ( 9600 ) ;
కోడ్
స్ట్రింగ్ వాల్;
శూన్యమైన సెటప్ ( ) {
}
శూన్య లూప్ ( ) {
ఉంటే ( సీరియల్.అందుబాటులో ఉంది ( ) ) { /* తనిఖీ కోసం సీరియల్ డేటా */
val = '' ;
అయితే ( సీరియల్.అందుబాటులో ఉంది ( ) ) { /* చదవండి సీరియల్ డేటా ఉంటే అందుబాటులో */
చార్ సీరియల్_డేటా = సీరియల్.చదవండి ( ) ;
విలువ =val+Serial_Data; /* కొత్త స్ట్రింగ్ లోపల డేటాను నిల్వ చేయండి */
}
Serial.println ( విలువ ) ; /* ముద్రించండి చదవండి సమాచారం */
సీరియల్.ఎండ్ ( ) ; /* సీరియల్ కమ్యూనికేషన్ ముగింపు */
సీరియల్.ప్రారంభం ( 9600 ) ; /* స్పష్టమైన సీరియల్ బఫర్ */
}
}
బాడ్ రేట్‌ని నిర్వచించడం ద్వారా సీరియల్ కమ్యూనికేషన్‌ను ప్రారంభించేందుకు Arduino Serial.begin() ఫంక్షన్‌లను ఉపయోగిస్తుంది, ఒకసారి ఈ ఫంక్షన్ ప్రారంభించబడిన తర్వాత Arduino మెమరీలో గతంలో నిల్వ చేసిన డేటా స్పష్టంగా కనిపిస్తుంది. ఇక్కడ మేము Serial.available() ఫంక్షన్‌ని ఉపయోగించి సీరియల్ డేటా కోసం తనిఖీ చేస్తాము ఒకసారి డేటా చదివిన తర్వాత అది కొత్త స్ట్రింగ్‌లో నిల్వ చేయబడుతుంది మరియు చివరగా Serial.begin(9600)ని ఉపయోగించి మేము Arduino సీరియల్ బఫర్‌ను క్లియర్ చేస్తాము.
గమనిక: మేము సీరియల్ బఫర్‌ను ఫ్లష్ చేయాలి ఎందుకంటే ఇది పరికరానికి డేటా పంపబడిందని మరియు పంపడానికి వేచి ఉండలేదని లేదా హోల్డ్‌లో ఉందని నిర్ధారిస్తుంది.
ముగింపు
Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయడానికి, అది బఫర్ మెమరీలో కొత్త డేటాను నిల్వ చేయగలదు Serial.flush() మరియు Serial begin లను ఉపయోగించవచ్చు. ఇది Arduino సీరియల్ బఫర్‌ను క్లియర్ చేయడానికి ఉపయోగించవచ్చు, అయితే దీన్ని నివారించడానికి మొత్తం డేటా ట్రాన్స్‌మిట్ అయిన తర్వాత మనం వేచి ఉండాలి, మేము Serial.begin() ఫంక్షన్‌తో కాసేపు లూప్‌ని ఉపయోగించవచ్చు, ఇది సీరియల్ బఫర్ నుండి ఇన్‌కమింగ్ డేటాను కూడా క్లియర్ చేయవచ్చు.