Arduino என்பது ஒரு மின்னணு தளமாகும், இது ஸ்கெட்ச் எனப்படும் குறியீடு வடிவில் பயனர்களிடமிருந்து வழிமுறைகளை எடுத்து அதற்கேற்ப வெளியீட்டை உருவாக்குகிறது. வழிமுறைகளைச் சேகரித்து அவற்றை ஒவ்வொன்றாகச் செயல்படுத்த, 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 ) ;
கையொப்பமிடப்படாத நீண்ட மில்லிஸ்_ஃப்ளஷ்ஸ்டார்ட் = மில்லிஸ் ( ) ; /* தற்போதைய 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 ) ;
கையொப்பமிடப்படாத நீண்ட மில்லிஸ்_ஃப்ளஷ்ஸ்டார்ட் = மில்லிஸ் ( ) ; /* தற்போதைய 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() செயல்பாட்டை நாங்கள் இப்போது வரை விளக்கினோம், ஆனால் இந்த செயல்பாடு தரவு முழுமையாக அனுப்பப்படும் வரை காத்திருக்க வேண்டும். கேள்விக்கான பதில் எளிது: இதைப் பயன்படுத்தி நாம் செய்யலாம் போது தொடர் நூலக செயல்பாட்டுடன் லூப்.
தொடரியல்
போது ( தொடர்.கிடைக்கிறது ( ) )
தொடர்.படிக்க ( ) ;
Serial.end ( ) ;
தொடர்.தொடங்கு ( 9600 ) ;
குறியீடு
சரம் வால்;
வெற்றிட அமைப்பு ( ) {
}
வெற்றிட வளையம் ( ) {
என்றால் ( தொடர்.கிடைக்கிறது ( ) ) { /* காசோலை க்கான தொடர் தரவு */
வால் = '' ;
போது ( தொடர்.கிடைக்கிறது ( ) ) { /* படி தொடர் தரவு என்றால் கிடைக்கும் */
கரி தொடர்_தரவு = தொடர்.வாசிப்பு ( ) ;
மதிப்பு =val+Serial_Data; /* புதிய சரத்திற்குள் தரவைச் சேமிக்கவும் */
}
Serial.println ( மதிப்பு ) ; /* அச்சிட படி தகவல்கள் */
Serial.end ( ) ; /* இறுதி தொடர் தொடர்பு */
தொடர்.தொடங்கு ( 9600 ) ; /* தெளிவானது தொடர் தாங்கல் */
}
}
பாட் வீதத்தை வரையறுப்பதன் மூலம் தொடர் தொடர்பை துவக்க Arduino Serial.begin() செயல்பாடுகளை பயன்படுத்துகிறது, இந்த செயல்பாடு துவக்கப்பட்டவுடன் Arduino நினைவகத்தில் முன்பு சேமிக்கப்பட்ட தரவு தெளிவாகிறது. இங்கே Serial.available() செயல்பாட்டைப் பயன்படுத்தி தொடர் தரவைச் சரிபார்ப்போம், தரவைப் படித்தவுடன் அது ஒரு புதிய சரத்திற்குள் சேமிக்கப்படும் மற்றும் கடைசியாக Serial.begin(9600) ஐப் பயன்படுத்தி Arduino தொடர் இடையகத்தை அழிப்போம்.
குறிப்பு: சாதனத்திற்கு தரவு அனுப்பப்பட்டிருப்பதையும், அனுப்புவதற்கு காத்திருக்கவில்லை அல்லது நிறுத்தி வைக்கப்படுவதையும் இது உறுதி செய்வதால், சீரியல் பஃபரை நாங்கள் ஃப்ளஷ் செய்ய வேண்டும்.
முடிவுரை
Arduino தொடர் இடையகத்தை அழிக்க, அது இடையக நினைவகத்திற்குள் புதிய தரவைச் சேமிக்க முடியும் Serial.flush() மற்றும் Serial begin ஐப் பயன்படுத்தலாம். Arduino தொடர் இடையகத்தை அழிக்க இதைப் பயன்படுத்தலாம், ஆனால் இதைத் தவிர்க்க எல்லா தரவும் அனுப்பப்பட்டவுடன் நாம் காத்திருக்க வேண்டும், Serial.begin() செயல்பாட்டுடன் சிறிது நேரம் சுழற்சியைப் பயன்படுத்தலாம், இது தொடர் இடையகத்திலிருந்து உள்வரும் தரவையும் அழிக்க முடியும்.