ஆர்டுயினோ ஸ்கெட்சுகளுக்குள் அர்டுயினோ போர்டு சரங்கள் அடிக்கடி பயன்படுத்தப்படுகின்றன. சரங்கள் என்பது எழுத்துக்களின் வரிசையாக தகவல்களைச் சேமிக்கும் வாக்கியங்களைப் போன்றது. அவை பயனர்களுடன் தொடர்புகொள்வதற்கு பயனுள்ளதாக இருக்கும், மேலும் கணினிகள் பயன்படுத்துவதற்கு அவற்றின் உள்ளே தகவல் சேமிக்கப்படும் போது குறைவான உபயோகமாக இருக்கும். வெவ்வேறு வழிகளைப் பயன்படுத்தி ஒன்றுக்கு மேற்பட்ட சரங்களை எவ்வாறு இணைக்கலாம் என்பதை இந்தக் கட்டுரை விவரிக்கும்.
Arduino இல் சரங்களை இணைக்கவும்
சரங்களை இணைப்பது என்பது எழுத்துகளின் பட்டியலைக் கொண்ட இரண்டு அல்லது அதற்கு மேற்பட்ட சரங்களை ஒரே சரத்தில் இணைப்பதாகும். நாம் C++ இல் செய்வது போலவே Arduino விலும் ஒருங்கிணைப்பு மிகவும் எளிமையானது, Arduino IDE இல் சரங்களை இணைக்க இரண்டு வழிகள் உள்ளன.
Arduino இல் சரங்களை இணைப்பதற்கான வழிகள்
Arduino இல் சரங்களை இணைக்க அடிக்கடி பயன்படுத்தப்படும் இரண்டு வழிகள் பின்வருமாறு:
-
- concat() செயல்பாட்டைப் பயன்படுத்துதல்
- Append “+” ஆபரேட்டரைப் பயன்படுத்துதல்
1. concat() செயல்பாட்டைப் பயன்படுத்துதல்
concat() செயல்பாடு கொடுக்கப்பட்ட அளவுருக்களை ஒரு சரத்துடன் இணைக்கலாம். ஒருங்கிணைப்புச் செயல்பாடு வெற்றிகரமாக இருந்தால், இந்தச் செயல்பாடு உண்மையாக இருக்கும், இல்லையெனில் அது தவறானதாக இருக்கும்.
தொடரியல்
concat() செயல்பாட்டின் தொடரியல்:
myString.concat ( அளவுரு )
மேலே உள்ள தொடரியல் இங்கே myString ஒரு சரம் சேமிக்கப்படும் மாறியாகும். போது அளவுரு என்பது மாறி, நாம் myString க்குள் சேர்க்க விரும்புகிறோம். அளவுருவானது ஃப்ளோட், சார், பைட், லாங், இன்ட், டபுள் மற்றும் சரம் போன்ற எந்த தரவு வகையையும் கொண்டிருக்கலாம்.
ஒரு முறை தொடர்பு () செயல்பாடு செயல்படுத்தப்படுகிறது myString மாற்றப்படும், ஏனெனில் கொடுக்கப்பட்ட அளவுரு இப்போது அதனுடன் இணைக்கப்பட்டு புதிய முடிவு myString மாறிக்குள் சேமிக்கப்படும்.
அளவுருக்கள்
இது பின்வரும் அளவுருக்களை எடுக்கும்:
-
- myString : ஒரு மாறி, அதன் தரவு வகை சரம்.
- அளவுரு: அனுமதிக்கப்பட்ட தரவு வகைகளைக் கொண்ட மாறி: சரம், சரம், சார், பைட், முழு எண்ணாக, கையொப்பமிடப்படாத எண்ணாக, நீண்ட, கையொப்பமிடப்படாத நீளம், மிதவை, இரட்டை.
வருவாய் மதிப்பு
இந்த செயல்பாடு இரண்டு மதிப்புகளை வழங்கும்:
உண்மை: சரம் வெற்றிகரமாக இணைக்கப்படும் போது.
பொய்: சரம் மாறாமல் இருக்கும்போது.
எடுத்துக்காட்டு நிரல்
வெற்றிட அமைப்பு ( ) {
தொடர்.தொடங்கு ( 9600 ) ; /* தொடர் தொடர்பு தொடங்குகிறது */
தொடர்.அச்சு ( 'மைஸ்ட்ரிங் முன் இணைப்பு =' ) ;
சரம் myString = 'லினக்ஸ்' ; /* myString துவக்கப்பட்டது */
Serial.println ( myString ) ; /* இணைப்பிற்கு முன் myString */
myString.concat ( 'hint.com' ) ; /* concat செயல்பாடு அழைக்கப்படுகிறது */
தொடர்.அச்சு ( 'myString after concat =' ) ;
Serial.println ( myString ) ; /* concat பிறகு myString */
}
வெற்றிட வளையம் ( ) {
}
இந்த குறியீடு இரண்டு சரங்களை எடுத்து, concat() செயல்பாட்டைப் பயன்படுத்தி அவற்றை ஒன்றாக மாற்றுகிறது. myString மாறி வரையறுக்கப்படுகிறது, இது concat() செயல்பாடு வாதத்திலிருந்து அளவுருக்களின் மதிப்பை எடுத்து தொடர் மானிட்டரில் அச்சிடுகிறது.
வெளியீடு
வெளியீடு concat() செயல்பாட்டிற்கு முன்னும் பின்னும் myString ஐக் காட்டுகிறது.
2. Arduino இல் Append Operator “+” ஐப் பயன்படுத்துதல்
சரங்களை இணைப்பதைச் செய்வதற்கான இரண்டாவது வழி, append operator ஐப் பயன்படுத்துவதாகும். + ”. append operator + ஐப் பயன்படுத்தி நாம் சரங்களை மாறிகளுடன் இணைக்கலாம் மற்றும் மாறிக்கான அனுமதிக்கப்பட்ட தரவு வகைகள் concat() செயல்பாட்டிற்கு சமமானதாகும். ஒரே வரியில் பல சரங்களை அல்லது மாறிகளை இணைக்க நாம் பலமுறை append operator ஐப் பயன்படுத்தலாம்.
தொடரியல்
பின்வருபவை append operator + ஐப் பயன்படுத்தி ஒருங்கிணைக்கப் பயன்படுத்தப்படும் தொடரியல்.
myString = parameter1 + parameter2 + ... + parameter_n;
இங்கே நாம் எத்தனை அளவுருக்களையும் இணைக்கலாம் மற்றும் வெளியீட்டை myString செயல்பாட்டில் சேமிக்கலாம். அளவுருக்களுக்கான அனுமதிக்கப்பட்ட தரவு வகைகள் int, double, float, double, char, byte மற்றும் string.
அளவுருக்கள்
இது எண்ணற்ற அளவுருக்களை எடுக்கலாம்.
-
- myString1: மாறி இது சரம்
- myString2: மாறி இது சரம்
- myStringN: மாறி இது சரம்
திரும்பு
இரண்டு வெவ்வேறு சரங்களின் கலவையின் விளைவாக ஒரு புதிய சரம் திரும்பப் பெறப்படும்.
எடுத்துக்காட்டு நிரல்
வெற்றிட அமைப்பு ( ) {
தொடர்.தொடங்கு ( 9600 ) ; /* தொடர் தொடர்பு தொடங்குகிறது */
சரம் s1 = 'லினக்ஸ்' ; /* சரம் 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 ) ; /* மூன்று சரங்கள் + ஆபரேட்டரைப் பயன்படுத்தி இணைக்கப்படுகின்றன */
}
வெற்றிட வளையம் ( ) {
}
மேலே உள்ள குறியீட்டில் இரண்டு சரங்கள் append operator ஐப் பயன்படுத்தி அடுத்து துவக்கப்படும் “+” s1 மற்றும் s2 ஆகிய இரண்டு சரங்களை இணைத்து அவற்றின் வெளியீட்டை ஒரு புதிய சரம் s3 க்குள் சேமித்து வைக்கிறோம்.
அடுத்து ஒரு int, char மற்றும் ஒரு மிதக்கும் புள்ளி மதிப்பு துவக்கப்பட்டு, ஐப் பயன்படுத்தி இணைக்கப்படும் “+” இயக்குபவர். இந்த வெளியீடுகள் அனைத்தும் தொடர் மானிட்டரில் அச்சிடப்படுகின்றன.
வெளியீடு
வெளியீட்டு சாளரத்தில் அனைத்து சரங்களும் பின்னிணைப்பு ஆபரேட்டரைப் பயன்படுத்தி ஒன்றிணைத்த பிறகு ஒவ்வொன்றாக அச்சிடப்படும். “+” .
முடிவுரை
Arduino நிரலாக்க சரங்கள் இரண்டு வெவ்வேறு வழிகளைப் பயன்படுத்தி இணைக்கப்படுகின்றன, இவை இரண்டும் C++ நிரலாக்கத்திலிருந்து பெறப்படுகின்றன. சரங்களை இணைக்கப் பயன்படுத்தப்படும் முதல் முறை Arduino குறியீட்டில் concat() செயல்பாட்டைப் பயன்படுத்துகிறது, இரண்டாவது append operator “+” ஐப் பயன்படுத்தி எளிமையானது. append operator ஐப் பயன்படுத்தி எத்தனை சரங்களை வேண்டுமானாலும் சேர்க்கலாம்.