ప్రోగ్రామింగ్ చేస్తున్నప్పుడు Arduino స్కెచ్‌లలో Arduino బోర్డుల తీగలను తరచుగా ఉపయోగిస్తారు. తీగలు అక్షరాల శ్రేణిగా సమాచారాన్ని నిల్వ చేసే వాక్యాల వంటివి. అవి వినియోగదారులతో కమ్యూనికేట్ చేయడానికి ఉపయోగపడతాయి మరియు కంప్యూటర్లు ఉపయోగించడానికి వాటి లోపల సమాచారం నిల్వ చేయబడినప్పుడు తక్కువ ఉపయోగకరంగా ఉంటాయి. ఈ కథనం వివిధ మార్గాలను ఉపయోగించి ఒకటి కంటే ఎక్కువ స్ట్రింగ్‌లను ఎలా కలపవచ్చో వివరిస్తుంది.
Arduino లో తీగలను సంగ్రహించండి
స్ట్రింగ్‌ల సంయోగం అంటే అక్షరాల జాబితాను కలిగి ఉన్న రెండు లేదా అంతకంటే ఎక్కువ స్ట్రింగ్‌లను కలిపి ఒకే స్ట్రింగ్‌లో కలపడం. మేము C++లో చేసినట్లే Arduinoలో సంయోగం చాలా సులభం, Arduino IDEలో స్ట్రింగ్‌లను సంగ్రహించడానికి రెండు మార్గాలు ఉన్నాయి.
Arduino లో తీగలను సంగ్రహించడానికి మార్గాలు
Arduinoలో తీగలను కలపడానికి తరచుగా ఉపయోగించే రెండు మార్గాలు క్రిందివి:
-
- concat() ఫంక్షన్‌ని ఉపయోగించడం
- అనుబంధం “+” ఆపరేటర్‌ని ఉపయోగించడం
1. concat() ఫంక్షన్ ఉపయోగించడం
concat() ఫంక్షన్ ఇచ్చిన పారామితులను స్ట్రింగ్‌తో జతచేయవచ్చు. సంయోగం ఆపరేషన్ విజయవంతమైతే ఈ ఫంక్షన్ కూడా ఒప్పు అని తిరిగి ఇవ్వవచ్చు లేకుంటే అది తప్పుగా తిరిగి వస్తుంది.
వాక్యనిర్మాణం
concat() ఫంక్షన్ యొక్క సింటాక్స్:
myString.concat ( పరామితి )
ఇక్కడ పై వాక్యనిర్మాణంలో myString స్ట్రింగ్ నిల్వ చేయబడిన వేరియబుల్. కాగా పరామితి వేరియబుల్, మేము myString లోపల జోడించాలనుకుంటున్నాము. పరామితి ఫ్లోట్, చార్, బైట్, లాంగ్, ఇంట్, డబుల్ మరియు స్ట్రింగ్ వంటి ఏదైనా డేటా రకాన్ని కలిగి ఉంటుంది.
ఒక సా రి concat() ఫంక్షన్ అమలు చేయబడింది myString మార్చబడుతుంది ఎందుకంటే ఇచ్చిన పరామితి ఇప్పుడు దానికి జోడించబడుతుంది మరియు కొత్త ఫలితం myString వేరియబుల్ లోపల సేవ్ చేయబడుతుంది.
పారామితులు
ఇది క్రింది పారామితులను తీసుకుంటుంది:
-
- myString : ఒక వేరియబుల్ దీని డేటా రకం స్ట్రింగ్.
- పరామితి: అనుమతించబడిన డేటా రకాలతో వేరియబుల్: స్ట్రింగ్, స్ట్రింగ్, చార్, బైట్, పూర్ణాంక, సంతకం చేయని పూర్ణం, పొడవు, సంతకం చేయని పొడవు, ఫ్లోట్, డబుల్.
రిటర్న్ విలువ
ఈ ఫంక్షన్ రెండు విలువలను అందించగలదు:
నిజం: స్ట్రింగ్ విజయవంతంగా జోడించబడినప్పుడు.
తప్పు: స్ట్రింగ్ మారకుండా ఉన్నప్పుడు.
ఉదాహరణ ప్రోగ్రామ్
శూన్యమైన సెటప్ ( ) {
సీరియల్.ప్రారంభం ( 9600 ) ; /* సీరియల్ కమ్యూనికేషన్ ప్రారంభమవుతుంది */
సీరియల్.ప్రింట్ ( 'కన్కాట్ ముందు myString =' ) ;
స్ట్రింగ్ myString = 'Linux' ; /* myString ప్రారంభించబడింది */
Serial.println ( myString ) ; /* concat ముందు myString */
myString.concat ( 'hint.com' ) ; /* concat ఫంక్షన్ అంటారు */
సీరియల్.ప్రింట్ ( 'కన్కాట్ తర్వాత myString =' ) ;
Serial.println ( myString ) ; /* concat తర్వాత myString */
}
శూన్య లూప్ ( ) {
}
ఈ కోడ్ రెండు స్ట్రింగ్‌లను తీసుకుంటుంది మరియు వాటిని concat() ఫంక్షన్‌ని ఉపయోగించి సవరిస్తుంది. myString వేరియబుల్ నిర్వచించబడింది, ఇది concat() ఫంక్షన్ ఆర్గ్యుమెంట్ నుండి పారామితుల విలువను తీసుకుంటుంది మరియు దానిని సీరియల్ మానిటర్‌లో ముద్రిస్తుంది.
అవుట్‌పుట్
అవుట్‌పుట్ మాకు concat() ఫంక్షన్‌కు ముందు మరియు తర్వాత myStringని చూపుతుంది.
2. Arduinoలో Append ఆపరేటర్ “+”ని ఉపయోగించడం
తీగలను కలపడం యొక్క రెండవ మార్గం అనుబంధం ఆపరేటర్‌ని ఉపయోగించడం ' + ”. append operator +ని ఉపయోగించి మేము స్ట్రింగ్‌లను వేరియబుల్స్‌తో కలుపుతాము మరియు వేరియబుల్ కోసం అనుమతించబడిన డేటా రకాలు concat() ఫంక్షన్‌కు సమానంగా ఉంటాయి. ఒకే లైన్‌లో బహుళ స్ట్రింగ్‌లు లేదా వేరియబుల్స్‌ను కలపడానికి మనం అనుబంధ ఆపరేటర్‌ని అనేకసార్లు ఉపయోగించవచ్చు.
వాక్యనిర్మాణం
అనుబంధం ఆపరేటర్ +ని ఉపయోగించి సంయోగం కోసం ఉపయోగించే సింటాక్స్ క్రింది విధంగా ఉంది.
myString = parameter1 + parameter2 + ... + parameter_n;
ఇక్కడ మనం ఎన్ని పారామితులనైనా సంగ్రహించవచ్చు మరియు అవుట్‌పుట్‌ను myString ఫంక్షన్‌లో నిల్వ చేయవచ్చు. పారామీటర్ల కోసం అనుమతించబడిన డేటా రకాలు int, డబుల్, ఫ్లోట్, డబుల్, చార్, బైట్ మరియు స్ట్రింగ్.
పారామితులు
ఇది అనంతమైన పారామితులను తీసుకోవచ్చు.
-
- myString1: వేరియబుల్ ఇది స్ట్రింగ్
- myString2: వేరియబుల్ ఇది స్ట్రింగ్
- myStringN: వేరియబుల్ ఇది స్ట్రింగ్
తిరిగి
రెండు వేర్వేరు స్ట్రింగ్‌ల కలయిక ఫలితంగా కొత్త స్ట్రింగ్ అందించబడుతుంది.
ఉదాహరణ ప్రోగ్రామ్
శూన్యమైన సెటప్ ( ) {
సీరియల్.ప్రారంభం ( 9600 ) ; /* సీరియల్ కమ్యూనికేషన్ ప్రారంభమవుతుంది */
స్ట్రింగ్ s1 = 'Linux' ; /* స్ట్రింగ్ s1 నిర్వచించబడింది */
స్ట్రింగ్ s2 = 'hint.com' ; /* స్ట్రింగ్ s2 నిర్వచించబడింది */
స్ట్రింగ్ s3 = s1 + s2;
Serial.println ( s3 ) ; /* s1+s2 + ఆపరేటర్ ఉపయోగించి సంగ్రహించబడింది */
s3 = s1 + s2 + 1 ;
Serial.println ( s3 ) ; /* + ఆపరేటర్‌ని ఉపయోగించి పూర్ణాంక సంకలనం చేయబడింది */
s3 = s1 + s2 + 'ఎ' ;
Serial.println ( s3 ) ; /* + ఆపరేటర్ ఉపయోగించి CHAR సంగ్రహించబడింది */
s3 = s1 + s2+ 1.1 ;
Serial.println ( s3 ) ; /* ఫ్లోటింగ్ పాయింట్ విలువ + ఆపరేటర్ ఉపయోగించి సంగ్రహించబడింది */
s3 = 'మీరు ఇక్కడ ఉన్నారు' + s1 + s2;
Serial.println ( s3 ) ; /* మూడు తీగలను + ఆపరేటర్‌ని ఉపయోగించి కలిపారు */
}
శూన్య లూప్ ( ) {
}
ఎగువ కోడ్‌లో అనుబంధం ఆపరేటర్‌ని ఉపయోగించి తర్వాత రెండు స్ట్రింగ్‌లు ప్రారంభించబడతాయి “+” మేము s1 మరియు s2 అనే రెండు స్ట్రింగ్‌లను కలిపేస్తాము మరియు వాటి అవుట్‌పుట్‌ను కొత్త స్ట్రింగ్ s3 లోపల నిల్వ చేస్తాము.
తదుపరి ఒక int, char మరియు ఒక ఫ్లోటింగ్-పాయింట్ విలువ ప్రారంభించబడి మరియు జోడించబడి ఉంటుంది “+” ఆపరేటర్. ఈ అవుట్‌పుట్‌లన్నీ సీరియల్ మానిటర్‌లో ముద్రించబడతాయి.
అవుట్‌పుట్
అవుట్‌పుట్ విండోలో అన్ని స్ట్రింగ్‌లు అనుబంధం ఆపరేటర్‌ని ఉపయోగించి వాటిని కలిపిన తర్వాత ఒక్కొక్కటిగా ముద్రించబడతాయి “+” .
ముగింపు
Arduino ప్రోగ్రామింగ్ స్ట్రింగ్స్‌లో రెండు విభిన్న మార్గాలను ఉపయోగించి కలుపుతారు, ఇవి రెండూ C++ ప్రోగ్రామింగ్ నుండి సంక్రమించాయి. స్ట్రింగ్‌లను సంగ్రహించడానికి ఉపయోగించే మొదటి పద్ధతి Arduino కోడ్‌లోని concat() ఫంక్షన్‌ను ఉపయోగిస్తుంది, రెండవది అనుబంధ ఆపరేటర్ “+”ని ఉపయోగించడం ద్వారా సరళమైనది. అనుబంధం ఆపరేటర్‌ని ఉపయోగించి ఎన్ని స్ట్రింగ్‌లనైనా జోడించవచ్చు.