Arduino நிபந்தனையின்படி நிரலின் தொடக்கத்திற்குச் செல்கிறது. Arduino சுழல்கள். நிரல் உரையில் நிபந்தனை மற்றும் கிளைகள்

வடிவமைப்பு க்கானசுருள் பிரேஸ்களில் இணைக்கப்பட்ட ஒரு தொகுதி அறிக்கைகளை மீண்டும் செய்யப் பயன்படுகிறது. அதிகரிப்பு கவுண்டர் பொதுவாக ஒரு சுழற்சியை அதிகரிக்கவும் முடிக்கவும் பயன்படுத்தப்படுகிறது. ஆபரேட்டர் க்கானதிரும்பத் திரும்பச் செயல்படும் எந்தவொரு செயலுக்கும் ஏற்றது மற்றும் பெரும்பாலும் தரவு/வெளியீட்டு சேகரிப்பு வரிசைகளுடன் இணைந்து பயன்படுத்தப்படுகிறது.

லூப் தலைப்பு க்கானமூன்று பகுதிகளைக் கொண்டுள்ளது:

க்கான (துவக்கம் ; நிலை ; அதிகரிப்பு) (ஆபரேட்டர்கள் ஒரு சுழற்சியில் செயல்படுத்தப்படுகிறார்கள்)

துவக்கம் முதலில் மற்றும் ஒரு முறை மட்டுமே செய்யப்படுகிறது. லூப்பில் ஒவ்வொரு முறையும், ஒரு நிபந்தனை சரிபார்க்கப்படுகிறது, அது உண்மையாக இருந்தால், அறிக்கைகளின் தொகுதி மற்றும் ஒரு அதிகரிப்பு செயல்படுத்தப்படும், பின்னர் நிபந்தனை மீண்டும் சரிபார்க்கப்படும். நிபந்தனையின் பூலியன் மதிப்பு தவறானதாக மாறும்போது, லூப் முடிவடைகிறது.

உதாரணமாக

// PWM pin int PWMpin = 10 ஐப் பயன்படுத்தி LEDயை மங்கச் செய்தல்; // 10 பின்ஸ் வெற்றிட அமைப்பிற்கான 470 ஓம் மின்தடையுடன் தொடரில் LED () ( // அமைப்பு தேவையில்லை) void loop() (க்கு (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

மிதிவண்டி க்கான C சுழல்களை விட மிகவும் நெகிழ்வானது க்கானபிற நிரலாக்க மொழிகளில், எடுத்துக்காட்டாக, BASIC. அரைப்புள்ளிகள் தேவைப்பட்டாலும், ஏதேனும் அல்லது மூன்று தலைப்பு கூறுகளும் தவிர்க்கப்படலாம். மேலும், லூப் துவக்கம், நிபந்தனை மற்றும் அதிகரிப்பு அறிக்கைகள் சுயாதீன மாறிகள் கொண்ட எந்த செல்லுபடியாகும் C அறிக்கையாகவும் இருக்கலாம், மேலும் மிதவைகள் உட்பட எந்த C தரவு வகையையும் பயன்படுத்தலாம். இவை சுழற்சிக்கு அசாதாரணமானவை க்கான ஆபரேட்டர் வகைகள் சில தரமற்ற சிக்கல்களுக்கு மென்பொருள் தீர்வை வழங்குவதை சாத்தியமாக்குகிறது.

எடுத்துக்காட்டாக, லூப் கவுண்டர் ஆபரேட்டரில் பெருக்கத்தைப் பயன்படுத்துவது மடக்கை முன்னேற்றத்தை உருவாக்க உங்களை அனுமதிக்கிறது:

For(int x = 2; x< 100; x = x * 1.5){ println(x); }

உருவாக்கியது: 2,3,4,6,9,13,19,28,42,63,94

மற்றொரு உதாரணம், ஒரு சுழற்சியைப் பயன்படுத்தி எல்இடிக்கு சிக்னல் அளவை சீராக குறைத்தல் அல்லது அதிகரிப்பது க்கான:

Void loop())( int x = 1; (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); என்றால் (i == 255) x = -1; / / அதிகபட்ச தாமதத்தில் கட்டுப்பாடு மாறுதல் (10)

லூப் தலைப்பு க்கானமூன்று பகுதிகளைக் கொண்டுள்ளது:

உதாரணமாக

For(int x = 2; x< 100; x = x * 1.5){ println(x); }

உருவாக்கியது: 2,3,4,6,9,13,19,28,42,63,94

வெற்றிட வளையம்() ( int x = 1; (int i = 0; i > -1; i = i + x)( analogWrite(PWMpin, i); என்றால் (i == 255) x = -1; // அதிகபட்ச தாமதத்தில் கட்டுப்பாடு மாறுதல் (10)

", கட்டுப்படுத்தியின் செயல்பாட்டை ஒழுங்கமைக்க "for" லூப்பை எவ்வாறு பயன்படுத்துவது என்பதை நாங்கள் கற்றுக்கொண்டோம். இந்த வகையான லூப் எல்லா இடங்களிலும் பயன்படுத்தப்படுகிறது மற்றும் "லூப்பிங் செயல்பாடுகளின் தேவையை" உள்ளடக்கியது. இருப்பினும், மற்றொரு வகை வளையம் உள்ளது - "அதே நேரத்தில்". இது லூப்பை விட சிறந்ததல்ல, இது வெவ்வேறு கொள்கைகளைப் பயன்படுத்துகிறது.

பெரும்பாலான சந்தர்ப்பங்களில், இரண்டு வகையான சுழல்களில் எதைப் பயன்படுத்த வேண்டும் என்பதை நீங்கள் தேர்வு செய்யலாம். பயனர் தேவையான தரவை உள்ளிடும் வரை நிரலை இடைநிறுத்த "while" ஐப் பயன்படுத்தினோம். இந்தப் பாடத்தில், Arduino இயங்குதளத்தை உதாரணமாகப் பயன்படுத்தி இந்த வளையம் எவ்வாறு செயல்படுகிறது என்பதை விரிவாகப் பார்ப்போம்.

2 LED களைக் கொண்ட சர்க்யூட்டுடன் தொடர்ந்து வேலை செய்வோம்.

கூடுதலாக, பாடம் 14 இல் நாங்கள் இறுதி செய்த குறியீட்டுடன் தொடர்ந்து பணியாற்றுவோம்.

மீண்டும் இறந்து காலத்திற்கு: கட்டுப்படுத்தி பயனரை தரவுக்காகத் தூண்டுகிறது, உள்ளீட்டிற்காக காத்திருக்கிறது, பின்னர் அதன் விளைவாக வரும் மதிப்புகளை மாறிகளுக்கு ஒதுக்குகிறது சிமிட்டும் எண் பச்சைமற்றும் சிமிட்டும் எண் சிவப்பு. 2 எல்இடிகளில் ஒவ்வொன்றும் எத்தனை முறை ஒளிரும் என்பதைக் கட்டுப்படுத்த இது பயனரை அனுமதிக்கிறது.

ஒரு புரோகிராமரின் உலகக் கண்ணோட்டத்தை விரிவுபடுத்த, அதே பணிகளைச் செயல்படுத்த இரண்டு வகையான சுழல்களைப் பயன்படுத்த கற்றுக்கொள்வது மதிப்பு, எதிர்காலத்தில் நீங்கள் ஒன்று அல்லது மற்றொரு வகைக்கு அனுதாபம் காட்டலாம்.

இது எவ்வாறு செயல்படுகிறது என்பதைக் கண்டுபிடிப்போம்:

முழு எண்ணாக z= 1 ; // ஒரு மாறியை அறிவித்து அதற்கு மதிப்பு 1 ஐ ஒதுக்கவும்

போது (z<=10) { //запускаем цикл போது

தொடர். println(z); // மாறியின் தற்போதைய மதிப்பை வெளியிடவும்z தொடர் துறைமுகம் வழியாக

z= z+1 // மாறியின் மதிப்பை அதிகரிக்கவும்z1 மூலம்

) // சுழற்சியை முடிக்கவும்

அடைப்புக்குறிக்குள் விவரிக்கப்பட்டுள்ள "நிபந்தனை" உண்மையாக இருக்கும் வரை, லூப் கட்டளைகளை இயக்கும். மேலே உள்ள எடுத்துக்காட்டில், z என்பது 10 ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருக்கும் வரை லூப் கட்டளைகளை தொடர்ந்து செயல்படுத்தும். லூப்பின் உடல் 2 கட்டளைகளை செயல்படுத்துகிறது:

சீரியல் போர்ட் வழியாக மாறியின் மதிப்பை வெளியிடுதல்;
ஒரு மாறியின் மதிப்பை 1 ஆல் அதிகரிப்பது (அறிவியல் ரீதியாக அதிகரிப்பு என்று அழைக்கப்படுகிறது).

மாறியின் மதிப்பை அதிகரிப்பதன் மூலம், நிரல் இறுதியில் லூப்பில் இருந்து வெளியேறும். இந்த வரியைக் குறிப்பிட மறந்துவிட்டோமோ அல்லது ஒருவித தோல்வி ஏற்பட்டதாகவோ ஒரு நொடி கற்பனை செய்தால், நிரல் மகிழ்ச்சியுடன் ஒரு வளையத்திற்குள் செல்லும் (வேறுவிதமாகக் கூறினால், அது உறைந்துவிடும்).

நிபந்தனையின் உண்மையைச் சரிபார்ப்பதன் மூலம் வளையம் அதன் வேலையைத் தொடங்குகிறது. z 10 ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருந்தால், நிரல் லூப்பை இயக்குகிறது. பின்னர் நிலை மீண்டும் சரிபார்க்கப்படுகிறது, முதலியன. மாறியின் மதிப்பு z = 11 ஐ அடையும் போது, நிபந்தனை இனி உண்மையாக இருக்காது. நிரல் லூப்பை இயக்காது மற்றும் லூப் கர்லி பிரேஸுக்குப் பிறகு உடனடியாக அடுத்த வரிக்குச் செல்லும்.

போதுமான கோட்பாடு, பயிற்சிக்கு செல்லலாம். மூலக் குறியீட்டில் for loops ஐ while loops என்று மாற்றுவோம்.

FOR சுழற்சியால் ஃப்ளாஷர் செய்யப்படுகிறது:

(int i = 1; i<= blinkNumberGreen; i++) // ஏவுதல் மிதிவண்டிக்கான

{

தொடர். அச்சு("பச்சை ஒளிர்ந்தது");

Serial.println(i);

டிஜிட்டல் ரைட் (கிரீன்லெட், உயர்); //இயக்கவும் பச்சை ஒளி உமிழும் டையோடு

தாமதம்(timeOnGreenLed); //நாங்கள் காத்திருக்கிறோம்

டிஜிட்டல் ரைட் (கிரீன்லெட், குறைந்த); //அணைக்க பச்சை ஒளி உமிழும் டையோடு

தாமதம் (timeOffGreenLed); //நாங்கள் காத்திருக்கிறோம்

}

Flasher in WHILE சுழற்சி:

முழு எண்ணாக நான்=1; //ஒரு மாறியை அறிவித்து அதற்கு மதிப்பு 1ஐ ஒதுக்கவும்

போது (i<= blinkNumberGreen)

{ // ஏவுதல் மிதிவண்டிபோது

Serial.print("பச்சை கண் சிமிட்டினார் «);

Serial.println(i);

டிஜிட்டல் ரைட் (கிரீன்லெட், ஹை); //இயக்கவும் பச்சை ஒளி உமிழும் டையோடு

தாமதம்(timeOnGreenLed); //நாங்கள் காத்திருக்கிறோம்

டிஜிட்டல் ரைட் (கிரீன்லெட், குறைந்த); //அணைக்க பச்சை ஒளி உமிழும் டையோடு

தாமதம் (timeOffGreenLed); //நாங்கள் காத்திருக்கிறோம்

நான்= நான்+1 //மாறியின் மதிப்பை 1 ஆல் அதிகரிக்கவும்

}

நிரலைச் சேமித்து, ஃபார்ம்வேரைக் கட்டுப்படுத்தியில் ஏற்றவும். முடிவைப் பார்ப்போம்.

அறிக்கைகளைப் பயன்படுத்தி சுழல்கள் க்கானமற்றும் போது Arduino ஐ அடிப்படையாகக் கொண்ட C++ மொழியின் மிக முக்கியமான கட்டுமானங்களில் ஒன்றாகும். நீங்கள் சந்தேகப்படாவிட்டாலும், அவை முற்றிலும் ஒவ்வொரு ஓவியத்திலும் காணப்படுகின்றன. இந்த கட்டுரையில், சுழல்களை நாம் கூர்ந்து கவனிப்போம், அதற்கும் நேரத்திற்கும் என்ன வித்தியாசம் என்பதைக் கண்டுபிடிப்போம், அவர்களின் உதவியுடன் ஒரு நிரலை எழுதுவதை எவ்வாறு எளிதாக்குவது, என்ன தவறுகளைத் தவிர்க்க வேண்டும்.

நீங்கள் இன்னும் ஒரு புதிய புரோகிராமராக இருந்தால், லூப் என்றால் என்ன, அது ஏன் தேவைப்படுகிறது என்பதைப் புரிந்து கொள்ள விரும்பினால், இந்த கட்டுரையின் அடுத்த பகுதியை விரிவான விளக்கத்துடன் பாருங்கள்.

C++ மற்றும் Arduino இல் அதே கட்டளைகளை தன்னிச்சையாக பல முறை செய்ய WHILE ஆபரேட்டர் பயன்படுத்தப்படுகிறது. FOR லூப்புடன் ஒப்பிடும்போது, WHILE லூப் எளிமையானதாகத் தெரிகிறது; மாறியில் உள்ள மறு செய்கைகளின் எண்ணிக்கையை நாம் கணக்கிடத் தேவையில்லை, ஆனால் ஏதாவது மாற்றங்கள் அல்லது ஏதேனும் நிகழ்வு ஏற்படும் வரை குறியீட்டை மீண்டும் செய்ய வேண்டும்.

WHILE தொடரியல்

போது(<условие или список условий>)
{
<программный блок, который будет повторяться>
}

பூலியன் மதிப்பை வழங்கும் எந்த மொழி கட்டமைப்பையும் நிபந்தனைகளாகப் பயன்படுத்தலாம். நிபந்தனைகள் ஒப்பீட்டு செயல்பாடுகள், செயல்பாடுகள், மாறிலிகள், மாறிகள். Arduino இல் உள்ள மற்ற தர்க்கரீதியான செயல்பாடுகளைப் போலவே, பூஜ்ஜியத்தைத் தவிர வேறு எந்த மதிப்பும் உண்மை, பூஜ்யம் - தவறு என உணரப்படும்.

// ஒரு முடிவற்ற வளைய போது(true)( Serial.println("Waiting..."); ) // checkSignal() செயல்பாட்டின் மதிப்பு மாறும் வரை (!checkSignal())( Serial.println ("காத்திருப்பது...");

சுருள் பிரேஸ்களுடன் பிளாக்கைத் தடுக்காமல் while ஸ்டேட்மெண்ட் பயன்படுத்தப்படலாம் என்பதை நினைவில் கொள்ளவும், இதில் லூப்பிற்குப் பிறகு எதிர்கொள்ளும் முதல் கட்டளை மீண்டும் மீண்டும் செய்யப்படும். சுருள் பிரேஸ்கள் இல்லாமல் பயன்படுத்த பரிந்துரைக்கப்படவில்லை, ஏனெனில் இந்த வழக்கில் தவறு செய்வது மிகவும் எளிதானது. உதாரணமாக:

போது(உண்மை) Serial.print("குறுக்கீடுக்காக காத்திருக்கிறது"); தாமதம்(1000);

இந்த வழக்கில், கல்வெட்டு இடைநிறுத்தங்கள் இல்லாமல் முடிவில்லாத சுழற்சியில் காட்டப்படும், ஏனெனில் தாமதம்(1000) கட்டளை மீண்டும் செய்யப்படாது. இதுபோன்ற பிழைகளைப் பிடிக்க நீங்கள் நிறைய நேரம் செலவிடலாம் - சுருள் பிரேஸைப் பயன்படுத்துவது மிகவும் எளிதானது.

பயன்பாட்டு உதாரணம் லூப் போது

பெரும்பாலும், சில நிகழ்வுகளுக்காக காத்திருக்கும் போது பயன்படுத்தப்படுகிறது. எடுத்துக்காட்டாக, வேலைக்கான தொடர் பொருளின் தயார்நிலை.

Serial.begin(9600); அதே சமயம் (! சீரியல்) ( ; // சில Arduino பலகைகள் சீரியல் போர்ட் இலவசம் வரை காத்திருக்க வேண்டும்)

UART வழியாக வெளிப்புற சாதனங்களிலிருந்து ஒரு எழுத்து வரும் வரை காத்திருப்பதற்கான எடுத்துக்காட்டு:

போது(Serial.available())( int byteInput = Seria.read(); // வேறு சில செயல்கள்)

இந்த வழக்கில், Serial.available() பூஜ்ஜியமற்ற மதிப்பை வழங்கும் வரை மதிப்புகளைப் படிப்போம். பஃபரில் உள்ள அனைத்து தரவுகளும் முடிந்தவுடன், லூப் நின்றுவிடும்.

Arduino இல் வளையத்திற்கு

FOR லூப்பில், எல்லை நிபந்தனைகளை அமைப்பது மட்டுமல்லாமல், கவுண்டருக்கான மாறியை உடனடியாக வரையறுத்து, ஒவ்வொரு மறு செய்கையிலும் அதன் மதிப்புகள் எவ்வாறு மாறும் என்பதைக் குறிப்பிடவும் எங்களுக்கு வாய்ப்பு உள்ளது.

லூப் தொடரியல்

இங்கே வடிவமைப்பு இன்னும் கொஞ்சம் சிக்கலானதாக இருக்கும்:
க்கான (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

எளிமையான உதாரணம்:

For(int i=5;i<10;i++){ // Конструкция «3 в одном» pinMode(i, OUTPUT); }

நாங்கள் உடனடியாக ஒரு மாறியை உருவாக்கி, அதை துவக்கி, ஒவ்வொரு சுழற்சியின் முடிவிலும் கவுண்டர் மதிப்பை ஒன்று அதிகரிக்க வேண்டும் என்று சுட்டிக்காட்டினோம். அவ்வளவுதான் - இப்போது நீங்கள் வளையத்திற்குள் மாறியைப் பயன்படுத்தலாம்.

மாறி படி வேறுபட்டிருக்கலாம். இங்கே உதாரணங்கள்:

for(int i=0; i<10; i=i+2) // Шаг 2
for(int i=0; i<10; i+=2) // Аналогичен предыдущему
for(int i=10; i>0; i–) // திரும்பிச் செல்லுங்கள் – 10 முதல் 1 வரை

லூப் போது செய்ய

சில சந்தர்ப்பங்களில், தொகுதியின் அறிவுறுத்தல்கள் ஒரு முறையாவது செயல்படுத்தப்படும் வகையில் வளையத்தை ஒழுங்கமைக்க வேண்டும், பின்னர் காசோலை மேற்கொள்ளப்படுகிறது. அத்தகைய அல்காரிதங்களுக்கு, நீங்கள் கட்டமைக்கும் போது do ஐப் பயன்படுத்தலாம். உதாரணமாக:

செய் (Serial.println("Working"); ) while (checkSomething());

இந்த லூப்பின் பதிப்பு எந்த சிரமத்தையும் ஏற்படுத்தாது - நாங்கள் நிபந்தனைகளுடன் பிளாக்கை நகர்த்தினோம், எனவே டூ ஆபரேட்டருக்குப் பிறகு சுருள் பிரேஸ்களுக்குள் உள்ள அனைத்து உள்ளடக்கங்களும் முதல் சோதனைக்கு முன் செயல்படுத்தப்படும்.

அறிக்கைகளைத் தொடரவும் மற்றும் உடைக்கவும்

நிபந்தனை சரிபார்ப்புத் தொகுதிக்குச் செல்லக் காத்திருக்காமல், லூப் பிளாக்கிற்குள் ஒரு லூப்பைச் செயல்படுத்துவதை நீங்கள் அவசரமாக குறுக்கிட வேண்டிய சூழ்நிலைகள் உள்ளன. இதைச் செய்ய, நீங்கள் ஆபரேட்டரைப் பயன்படுத்தலாம் உடைக்க:

போது (உண்மை) (எனில் (எதையாவது சரிபார்க்கவும் ()) ( முறிவு; ) )

தற்போதைய மறு செய்கையின் முன்னேற்றத்தை நிறுத்த வேண்டும், ஆனால் லூப்பில் இருந்து வெளியேறாமல், நிபந்தனை சரிபார்ப்பு தொகுதிக்குச் செல்ல வேண்டும் என்றால், நாம் ஆபரேட்டரைப் பயன்படுத்த வேண்டும். தொடரவும்:

போது (உண்மை) ((செக் சம்திங்()) (தொடரவும்;) )

தொடர் மற்றும் இடைவேளை அறிக்கைகள் FOR மற்றும் WHILE லூப்களின் அனைத்து வகைகளிலும் பயன்படுத்தப்படலாம்.

Arduino இல் உள்ளமைக்கப்பட்ட சுழல்கள்

சுழல்களின் எந்த மாறுபாடுகளும் எளிதாக ஒருவருக்கொருவர் இணைக்கப்பட்டு, உள்ளமைக்கப்பட்ட கட்டமைப்புகளை உருவாக்குகின்றன. "அதிகப்படியான" வளையத்தின் தொகுதியில் வரையறுக்கப்பட்ட மாறிகள் உட்புறத்தில் கிடைக்கும். இந்த வகையான சுழற்சியின் மிகவும் பொதுவான உதாரணம் இரு பரிமாண வரிசைகளை கடந்து செல்வதாகும். பின்வரும் எடுத்துக்காட்டில், நாங்கள் ஒரு இரட்டை வளையத்தைப் பயன்படுத்துகிறோம்: முதலாவது வரிசைகள் (மாறி i) மூலம் மீண்டும் செய்யும், இரண்டாவது, உள்ளமை, வரிசையின் நெடுவரிசைகள் (மாறி j) வழியாகச் செல்லும், அதை நாம் மாறி arr இல் வரையறுத்துள்ளோம்.

Int arr; void setup() ( (int i = 0; i.)< 10; i++) { for (int j = 0; j < 3; j++) { arr[i][j] = i * j; Serial.println(arr[i][j]); } } }

சுழற்சிகள் பற்றி மேலும்

நீங்கள் ஒருபோதும் லூப்களுடன் வேலை செய்யவில்லை என்றால், கோட்பாட்டின் உலகில் கொஞ்சம் மூழ்கி, சுழல்கள் என்றால் என்ன, இந்த மர்மமான மொழி கட்டமைப்புகள் ஏன் தேவை என்பதைக் கண்டுபிடிப்போம்.

நமக்கு ஏன் ஒரு வளையம் தேவை?

உண்மையில், லூப்பின் முக்கிய பணி ஒரே மொழி கட்டமைப்பை பல முறை மீண்டும் செய்வதாகும். இந்த தேவை கிட்டத்தட்ட ஒவ்வொரு நிரலிலும் எழுகிறது, நிச்சயமாக ஒரு Arduino ஸ்கெட்ச் ஒரு லூப் இல்லாமல் செய்ய முடியாது - லூப் () செயல்பாடு ஒரு எல்லையற்ற வளையத்தில் அழைக்கப்படுகிறது.

பின்வரும் உதாரணத்தைப் பார்ப்போம். ஊசிகள் 5 முதல் 9 வரை Arduino போர்டுடன் இணைக்கப்பட்ட 5 LED களுக்கு ஒரே நேரத்தில் மின்சாரம் வழங்க வேண்டும். ஒரு வரிசையில் ஐந்து வழிமுறைகளை வைப்பதே இதற்கான மிகத் தெளிவான விருப்பம்:

டிஜிட்டல் ரைட் (5, உயர்);

டிஜிட்டல் ரைட்(6, உயர்);

டிஜிட்டல் ரைட்(7, உயர்);

டிஜிட்டல் ரைட்(8, உயர்);

டிஜிட்டல் ரைட்(9, உயர்);

அத்தகைய செயலின் ஆபத்து பற்றிய சிக்கலை இப்போதைக்கு புறக்கணிப்போம், ஏனென்றால் ஒரே நேரத்தில் பல எல்.ஈ.டிகளைச் சேர்ப்பது போர்டின் மின்சுற்றில் அதிகரித்த சுமையை உருவாக்குகிறது. இப்போது எங்களுக்கு முக்கிய விஷயம் என்னவென்றால், நாங்கள் ஐந்து வரி குறியீட்டை உருவாக்கியுள்ளோம், அவை ஒவ்வொன்றும் மற்றவற்றிலிருந்து ஒரு இலக்கத்தால் வேறுபடுகின்றன. இந்த அணுகுமுறை பின்வரும் குறைபாடுகளைக் கொண்டுள்ளது:

எந்த மாற்றத்துடன், நீங்கள் ஒரே நேரத்தில் பல வரிகளில் மாற்றங்களைச் செய்ய வேண்டும். எடுத்துக்காட்டாக, LED களை பின்கள் 2 முதல் 6 வரை மாற்ற வேண்டும் அல்லது மின்னழுத்தத்தை ஆன் செய்வதற்குப் பதிலாக அணைக்க வேண்டும் என்றால், குறியீட்டில் 5 மாற்றங்களைச் செய்ய வேண்டும். மேலும் அறிவுறுத்தல்கள் மற்றும் மாற்றங்கள் இருந்தால் என்ன செய்வது?
அதிக எண்ணிக்கையிலான ஒத்த வழிமுறைகளைக் கொண்ட பெரிய குறியீடு படிக்க சிரமமாகவும் விரும்பத்தகாததாகவும் இருக்கும். ஒரே மாதிரியான ஐந்து கோடுகள் மிகவும் பயமாக இல்லை. ஆனால் அழுக்கு குறியீட்டின் பழக்கம் இறுதியில் பல்லாயிரக்கணக்கான மற்றும் நூற்றுக்கணக்கான கூடுதல் பக்கங்களுக்கு பட்டியலில் வழிவகுக்கும், இது உங்களையும் உங்கள் சக ஊழியர்களையும் ஏமாற்றமடையச் செய்யும்.
கிட்டத்தட்ட ஒரே மாதிரியான வழிமுறைகளை "நகல்-பேஸ்டிங்" செயல்பாட்டில், நீங்கள் எளிதாக தவறு செய்யலாம், உதாரணமாக, பின் எண்ணை மாற்ற மறந்துவிடலாம்: டிஜிட்டல் ரைட்(5, உயர்); டிஜிட்டல் ரைட் (5, உயர்);
நேர்காணல் செய்பவருக்கு இந்தக் குறியீட்டைக் காண்பிப்பதன் மூலம், எந்தவொரு சாதாரண மென்பொருள் நிறுவனத்திலும் நேர்காணலில் நீங்கள் எளிதாக தோல்வியடையலாம்.

இவை அனைத்திலிருந்தும், அதே சரங்களை மீண்டும் மீண்டும் பயன்படுத்துவது கிட்டத்தட்ட எப்போதும் தவிர்க்கப்பட வேண்டும் மற்றும் சுழல்களால் மாற்றப்பட வேண்டும் என்று நாம் முடிவு செய்யலாம். மேலும், பல சூழ்நிலைகளில் சுழற்சிகள் இல்லாமல் செய்ய முடியாது; நிரல் இயங்கும் போது குறியீட்டை மீண்டும் மீண்டும் செய்யும் எண்ணிக்கையை நீங்கள் மாற்ற முடியாது. உதாரணமாக, நீங்கள் ஒவ்வொரு உறுப்புகளையும் செயலாக்க வேண்டும் தரவு வரிசை, வெளிப்புற சாதனங்களிலிருந்து பெறப்பட்டது. எவ்வளவு தரவு இருக்கும், எத்தனை முறை செயலாக்கம் மீண்டும் செய்யப்படும் என்பதை நீங்கள் ஒருபோதும் கணிக்க மாட்டீர்கள், எனவே கட்டுரையை எழுதும் நேரத்தில் தேவையான எண்ணிக்கையிலான வழிமுறைகளை நீங்கள் செருக முடியாது.

இங்கே சுழற்சிகள் நமக்கு உதவுகின்றன.

தொடரியல் விதிகள்

Arduino இல் லூப்நிரல் செயலாக்கத்தின் போது குறிப்பிட்ட எண்ணிக்கையிலான முறை அழைக்கப்படும் ஒரு சிறப்பு நிரல் தொகுதி. இந்தத் தொகுதிக்குள், அழைக்கப்படும் கட்டளைகள் மற்றும் அவை எத்தனை முறை அழைக்கப்பட வேண்டும் என்பதை கட்டுப்படுத்தி தீர்மானிக்கும் விதிகளை நாங்கள் விவரிக்கிறோம்.

மேலே உள்ள எங்கள் எடுத்துக்காட்டில், கட்டுப்படுத்திக்கு பின்வருவனவற்றைச் சொல்லலாம்:

கட்டளையை மீண்டும் செய்யவும் டிஜிட்டல் 5 முறை எழுதவும்

ரோபோ புரோகிராமர்களைக் கொண்ட ஒரு சிறந்த உலகில், இது போதுமானதாக இருக்கும், ஆனால் நாம் கணினியுடன் C++ இல் பேசுவதால், இந்த சொற்றொடரை இந்த மொழியில் மொழிபெயர்க்க வேண்டும்:

கட்டளையை மீண்டும் செய்யவும் - சுவாரசியமான ஒன்று தொடங்கும் போது அல்லது லூப்களுக்கு என்று கட்டுப்படுத்திக்கு சொல்லும் சிறப்பு வழிமுறைகளை நீங்கள் பயன்படுத்த வேண்டும்

டிஜிட்டல் ரைட் - அதை அப்படியே விட்டு விடுங்கள், ஆனால் அதை ஒரு முறை எழுதி சுருள் பிரேஸ்களில் இணைக்கவும். பின் எண்களை என்ன செய்வது - கீழே.

5 முறை - இதற்கு ஒரு கவுண்டரைப் பயன்படுத்தவும், இது ஒவ்வொரு மறுபடியும் அதிகரிக்கும். ஒரு தொகுதியின் தொடக்கத்தில் (அல்லது முடிவில்), ஒப்பீட்டுச் செயல்பாட்டைப் பயன்படுத்தி இந்த கவுண்டரின் மதிப்பை வரம்பு மதிப்புடன் (இந்த வழக்கில் 5) ஒப்பிடலாம்.

சிறிது நேரம் அறிக்கையுடன் அத்தகைய "மொழிபெயர்க்கப்பட்ட" லூப் கட்டளையின் உதாரணத்தைப் பார்ப்போம்:

Int கவுண்டர் = 0; // கவுண்டர் மதிப்பைச் சேமிக்கும் ஒரு மாறி // அடைப்புக்குறிக்குள் உள்ள நிபந்தனை உண்மையாகும் வரை சுருள் பிரேஸ்களில் கட்டமைப்பை மீண்டும் செய்யுமாறு செயலியைக் கேட்டுக்கொள்கிறோம். // எங்கள் விஷயத்தில், கவுண்டர் என்பது எங்கள் கவுண்டர், 5 என்பது வரம்பு மதிப்பு, நிபந்தனை என்னவென்றால், கவுண்டர் மதிப்பு 5 க்கும் குறைவாக இருக்க வேண்டும். // ஆனால் நாம் முற்றிலும் மாறுபட்ட தருக்க ஆபரேட்டர்களை (எதிர்< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

கொடுக்கப்பட்ட குறியீட்டில் பிழை இருப்பதைக் கவனித்தவர்களுக்கு, நாங்கள் ஐந்தைக் கொடுத்து, லூப் பிளாக்கை வித்தியாசமாக எழுதுகிறோம்:

போது(எதிர்< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

FOR லூப்பைப் பயன்படுத்தி அதே முடிவை அடையலாம்:

For(int counter =0; counter<5; counter ++){ digitalWrite(counter+5, HIGH); }

நீங்கள் பார்க்க முடியும் என, இந்த விஷயத்தில் உடனடியாக தேவையான அனைத்து செயல்பாடுகளையும் கவுண்டருடன் ஒரு அறிவுறுத்தலுக்காக வைக்கிறோம் - தேவையான தொகையை நீங்கள் கணக்கிட வேண்டும் என்றால் இது மிகவும் வசதியானது.

இந்த கட்டுரையின் தொடர்புடைய பிரிவுகளில் சுழல்களைப் பயன்படுத்துவதற்கான விதிகள் பற்றிய விரிவான தகவல்களை நீங்கள் பெறலாம்.

முடிவுரை

இந்தக் கட்டுரையில், Arduino மொழியின் மிக முக்கியமான கட்டுமானங்களைப் பார்த்தோம்: FOR மற்றும் WHILE சுழல்கள். இந்த ஆபரேட்டர்களை நீங்கள் ஏறக்குறைய அதிகமாகவோ அல்லது குறைவாகவோ சிக்கலான ஓவியத்தில் காணலாம், ஏனெனில் சுழல்கள் இல்லாமல் தரவுகளில் பல செயல்பாடுகள் சாத்தியமற்றது. சுழல்களின் தொடரியல் சிக்கலான எதுவும் இல்லை - நீங்கள் அவற்றை எளிதாகப் பழகலாம் மற்றும் உங்கள் திட்டங்களில் அவற்றை தீவிரமாகப் பயன்படுத்தலாம்.

/ /

ஆபரேட்டருக்கு

லூப் தலைப்பு க்கானமூன்று பகுதிகளைக் கொண்டுள்ளது:

க்கான (துவக்கம்; நிலை; அதிகரிப்பு) (ஆபரேட்டர்கள் ஒரு சுழற்சியில் செயல்படுத்தப்படுகிறார்கள்)

உதாரணமாக

மிதிவண்டி க்கான C சுழல்களை விட மிகவும் நெகிழ்வானது க்கானபிற நிரலாக்க மொழிகளில், எடுத்துக்காட்டாக, BASIC. அரைப்புள்ளிகள் தேவைப்பட்டாலும், ஏதேனும் அல்லது மூன்று தலைப்பு கூறுகளும் தவிர்க்கப்படலாம். மேலும், லூப் துவக்கம், நிபந்தனை மற்றும் அதிகரிப்பு அறிக்கைகள் சுயாதீன மாறிகள் கொண்ட எந்த செல்லுபடியாகும் C அறிக்கையாகவும் இருக்கலாம், மேலும் மிதவைகள் உட்பட எந்த C தரவு வகையையும் பயன்படுத்தலாம். இவை சுழற்சிக்கு அசாதாரணமானவை க்கானஆபரேட்டர் வகைகள் சில தரமற்ற சிக்கல்களுக்கு மென்பொருள் தீர்வை வழங்குவதை சாத்தியமாக்குகிறது.

For(int x = 2; x< 100; x = x * 1.5){ println(x); }

உருவாக்கியது: 2,3,4,6,9,13,19,28,42,63,94