Arduino ప్రోగ్రామింగ్‌లోని ముఖ్య భావనలలో ఒకటి ఫంక్షన్‌లు, ఇది పునర్వినియోగ కోడ్‌ను వ్రాయడానికి మరియు మాడ్యులర్ ప్రోగ్రామ్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. విధులు విలువలను కూడా అందించగలవు, ఇవి మీ ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి లేదా గణనలను చేయడానికి ఉపయోగించవచ్చు.
ఈ వ్యాసంలో, మేము Arduino ని అన్వేషిస్తాము తిరిగి ఫంక్షన్ మరియు ఫంక్షన్ నుండి విలువలను తిరిగి ఇవ్వడానికి ఇది ఎలా ఉపయోగించబడవచ్చు.
Arduino తిరిగి
ఆర్డునో తిరిగి ఫంక్షన్ నుండి నిష్క్రమించడానికి మరియు కాలర్‌కు విలువను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది. తిరిగి వచ్చిన విలువను కాలర్ తదుపరి గణనలను చేయడానికి లేదా ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి ఉపయోగించవచ్చు. రిటర్న్ ఫంక్షన్ ప్రోగ్రామింగ్‌లో ఒక ముఖ్యమైన అంశం, ఎందుకంటే ఇది కోడ్‌ను మళ్లీ ఉపయోగించుకోవడానికి మరియు మాడ్యులర్ ప్రోగ్రామ్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.
వాపసు సింటాక్స్
Arduinoలో, రిటర్న్ ఫంక్షన్ కింది వాక్యనిర్మాణాన్ని కలిగి ఉంటుంది:
[ తిరిగి_రకం ] ఫంక్షన్_పేరు ( [ పారామితులు ] ) {
// ఫంక్షన్ బాడీ
తిరిగి [ తిరిగి_విలువ ] ;
}
ఎక్కడ:
తిరిగి_రకం తిరిగి ఇవ్వబడిన విలువ యొక్క డేటా రకం. ఇది Int, float, char, boolean మొదలైన ఏదైనా డేటా రకం కావచ్చు. విలువ ఏదీ అందించబడకపోతే, return_type చెల్లదు.
ఫంక్షన్_పేరు అనేది ఒక ఫంక్షన్ కోసం నిర్వచించబడిన పేరు, దీని విలువ తిరిగి ఇవ్వబడుతుంది.
పారామితులు ఫంక్షన్‌కు పంపగలిగే విలువలు. పారామితులు ఏవీ లేకుంటే పారామితులు ఐచ్ఛికం, వాటిని ఖాళీగా ఉంచండి. ప్రతి పరామితి డేటా రకాన్ని కలిగి ఉంటుంది, దాని తర్వాత పారామీటర్ పేరు ఉంటుంది. బహుళ పారామితులు కామాలతో వేరు చేయబడ్డాయి.
తిరిగి_విలువ ఫంక్షన్ ద్వారా అందించబడే విలువ. తిరిగి ఇవ్వబడిన విలువ తప్పనిసరిగా దానితో సరిపోలే అదే డేటా రకాన్ని కలిగి ఉండాలి తిరిగి_రకం ఫంక్షన్ లోపల పేర్కొనబడింది.
ఇక్కడ ఒక ఉదాహరణ Arduinoలో రిటర్న్ ఫంక్షన్ రెండు పారామితులను తీసుకొని పూర్ణాంక విలువను అందిస్తుంది:
int రెండు సంఖ్యలను జోడించండి ( int సంఖ్య 1, int సంఖ్య2 ) {int ఫలితం = సంఖ్య1 + సంఖ్య2 ;
తిరిగి ఫలితం ;
}
ఈ ఉదాహరణలో, ఫంక్షన్ రెండు సంఖ్యలను జోడించండి num1 మరియు num2 అనే రెండు పూర్ణాంకాల పారామితులను తీసుకుంటుంది, వాటిని ఒకదానితో ఒకటి జోడించి, ఫలితాన్ని పూర్ణాంక విలువగా అందిస్తుంది. మీ కోడ్‌లో ఈ ఫంక్షన్‌ని కాల్ చేయడానికి, మీరు ఇలాంటివి వ్రాస్తారు:
int a = 10 ;int బి = ఇరవై ;
int సి = రెండు సంఖ్యలను జోడించండి ( ఎ, బి ) ; // c 30కి సమానంగా ఉంటుంది
Arduino రిటర్న్ ఉపయోగించి ఏదైనా డేటా రకాన్ని తిరిగి ఇవ్వండి
ఆర్డునోలోని రిటర్న్ ఫంక్షన్‌తో సహా ఏదైనా డేటా రకాన్ని తిరిగి ఇవ్వడానికి ఉపయోగించవచ్చు పూర్ణాంకాలు , పాత్రలు , మరియు తీగలను . విలువను తిరిగి ఇవ్వడానికి దాని డేటా రకాన్ని తప్పనిసరిగా ఫంక్షన్ డిక్లరేషన్ లోపల ప్రకటించాలి. ఉదాహరణకు, పూర్ణాంకం తిరిగి ఇవ్వవలసి వస్తే, మీరు విధిని క్రింది విధంగా ప్రకటించాలి:
int myFunction ( ) {// కోడ్
తిరిగి విలువ ;
}
ఈ ఉదాహరణలో, ఫంక్షన్ ఒక అందిస్తుంది పూర్ణ సంఖ్య విలువ. ఫంక్షన్‌కు కాల్ చేయడానికి, దిగువన ఉన్న విధంగా వేరియబుల్‌కు రిటర్న్ విలువను కేటాయించడం అవసరం:
int ఫలితం = myFunction ( ) ;ఫంక్షన్ నుండి తిరిగి వచ్చే విలువ తదుపరి గణనలకు లేదా ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి ఉపయోగించబడుతుంది. ఉదాహరణకు, if స్టేట్‌మెంట్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి మీరు రిటర్న్ విలువను ఉపయోగించవచ్చు:
ఉంటే ( ఫలితం == 0 ) {// కోడ్
}
షరతు నిజమైతే మాత్రమే ఎగువ కోడ్ అమలు చేయబడుతుంది అంటే తిరిగి వచ్చిన విలువ 0కి సమానం.
Arduino రిటర్న్ ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌ను తిరిగి ఇవ్వండి
ఆర్డునోలో రిటర్న్ ఫంక్షన్ యొక్క మరొక ఉపయోగం రిటర్న్ a స్ట్రింగ్ . స్ట్రింగ్‌ను తిరిగి ఇవ్వడానికి, మీరు తప్పనిసరిగా Arduinoలోని స్ట్రింగ్ క్లాస్‌ని ఉపయోగించాలి. ఉదాహరణకి:
స్ట్రింగ్ మైఫంక్షన్ ( ) {తిరిగి 'హలో, వరల్డ్!' ;
}
ఈ ఉదాహరణలో, ఫంక్షన్ aని అందిస్తుంది స్ట్రింగ్ విలువ. ఫంక్షన్‌ను కాల్ చేయడానికి, తిరిగి వచ్చిన విలువ కోసం వేరియబుల్‌ను కేటాయించండి:
స్ట్రింగ్ ఫలితం = myFunction ( ) ;ఫలితం వేరియబుల్ విలువ ఇప్పుడు 'హలో, వరల్డ్!'కి సమానం.
Arduino రిటర్న్ ఫంక్షన్‌ని ఉపయోగించి బహుళ విలువలను తిరిగి ఇవ్వండి
ఆర్డునోలోని రిటర్న్ ఫంక్షన్ బహుళ విలువలను అందించడానికి కూడా ఉపయోగించవచ్చు. దీన్ని చేయడానికి, మీరు విలువలను నిల్వ చేయడానికి శ్రేణి లేదా నిర్మాణాన్ని ఉపయోగించాలి. ఉదాహరణకు, రెండు పూర్ణాంకాల విలువలను అందించడానికి క్రింది సింటాక్స్ ఉపయోగించవచ్చు:
శూన్యం myFunction ( int & a, int & బి ) {a = 1 ;
బి = 2 ;
}
ఇందులో ఉదాహరణ , ఫంక్షన్ రెండు పూర్ణాంకాల విలువలను ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు వాటిని కాలర్‌కు అందిస్తుంది. ఫంక్షన్‌కి కాల్ చేయడానికి, మీరు ఫంక్షన్‌కు రెండు వేరియబుల్స్ పాస్ చేయాలి:
int ఎ, బి ;myFunction ( ఎ, బి ) ;
ఇక్కడ a అనేది 1కి సమానం మరియు b విలువ 2 ఉంటుంది.
Arduino ఉదాహరణ కోడ్
Arduino లో రిటర్న్ ఫంక్షన్ యొక్క ఉపయోగాన్ని ప్రదర్శించే ఉదాహరణ ప్రోగ్రామ్ ఇక్కడ ఉంది:
int రెండు సంఖ్యలను జోడించండి ( int సంఖ్య 1, int సంఖ్య2 ) {int ఫలితం = సంఖ్య1 + సంఖ్య2 ;
తిరిగి ఫలితం ;
}
శూన్యం సెటప్ ( ) {
క్రమ. ప్రారంభం ( 9600 ) ;
int a = 10 ;
int బి = ఇరవై ;
int సి = రెండు సంఖ్యలను జోడించండి ( ఎ, బి ) ;
క్రమ. println ( 'రెండు సంఖ్యలను జోడించడం వల్ల వచ్చే ఫలితం:' + స్ట్రింగ్ ( సి ) ) ;
}
శూన్యం లూప్ ( ) {
// లూప్‌ను ఖాళీగా ఉంచండి
}
ఈ కార్యక్రమంలో ది రెండు సంఖ్యలను జోడించండి ఫంక్షన్ రెండు పూర్ణాంకాల పారామితులను తీసుకుంటుంది సంఖ్య1 మరియు సంఖ్య2 మరియు ఆ సంఖ్యల మొత్తాన్ని పూర్ణాంకంగా అందిస్తుంది. సెటప్ ఫంక్షన్ సీరియల్ కమ్యూనికేషన్‌ను ప్రారంభిస్తుంది మరియు addTwoNumbers ఫంక్షన్‌ని కాల్ చేస్తుంది, 10 మరియు 20 విలువలను పారామీటర్‌లుగా పాస్ చేస్తుంది. ఫలితం లో నిల్వ చేయబడుతుంది సి వేరియబుల్, ఆపై అది ఉపయోగించి సీరియల్ మానిటర్‌కు ముద్రించబడుతుంది Serial.println ఫంక్షన్. లూప్ ఫంక్షన్‌లో, కోడ్ లేదు, అయితే అవసరమైతే మీరు మీ స్వంత కోడ్‌ను జోడించవచ్చు.
మీరు ఆర్డునోలో రిటర్న్ ఫంక్షన్‌ను ఎలా ఉపయోగించవచ్చో చెప్పడానికి ఇది కేవలం ఒక ఉదాహరణ. మీరు మీ అవసరాలను బట్టి అనేక విధాలుగా ఫంక్షన్ నుండి విలువను తిరిగి ఇవ్వడానికి రిటర్న్ ఫంక్షన్‌ని ఉపయోగించవచ్చు.
అవుట్‌పుట్
సీరియల్ మానిటర్ అవుట్‌పుట్‌లో రెండు సంఖ్యల మొత్తం మొత్తం 30 ప్రదర్శించబడుతుంది.
ముగింపు
ఆర్డునో తిరిగి ఫంక్షన్ ఒక ఫంక్షన్ నుండి కాలర్‌కు విలువలను తిరిగి ఇవ్వడానికి శక్తివంతమైన మరియు సౌకర్యవంతమైన మార్గాన్ని అందిస్తుంది. పూర్ణాంకాలు, అక్షరాలు మరియు స్ట్రింగ్‌లతో సహా ఏదైనా డేటా రకాన్ని తిరిగి ఇవ్వడానికి రిటర్న్ ఫంక్షన్ ఉపయోగించబడుతుంది. రిటర్న్ ఫంక్షన్ మిమ్మల్ని కోడ్‌ని మళ్లీ ఉపయోగించడానికి మరియు మరింత సమర్థవంతంగా మరియు చదవగలిగే మాడ్యులర్ ప్రోగ్రామ్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.