ออกแบบ สำหรับใช้เพื่อทำซ้ำบล็อกคำสั่งที่อยู่ในวงเล็บปีกกา โดยทั่วไปตัวนับการเพิ่มจะใช้เพื่อเพิ่มและยุติการวนซ้ำ ผู้ดำเนินการ สำหรับเหมาะสำหรับกิจกรรมที่เกิดซ้ำๆ และมักใช้ร่วมกับอาร์เรย์รวบรวมข้อมูล/เอาต์พุต

ส่วนหัวของห่วง สำหรับประกอบด้วยสามส่วน:

สำหรับ (การเริ่มต้น ; เงื่อนไข ; เพิ่มขึ้น) (ตัวดำเนินการดำเนินการในลูป)

การเริ่มต้นจะดำเนินการในครั้งแรกและครั้งเดียวเท่านั้น แต่ละครั้งในลูป จะมีการตรวจสอบเงื่อนไข หากเป็นจริง จะมีการดำเนินการบล็อกของคำสั่งและส่วนเพิ่ม จากนั้นเงื่อนไขจะถูกตรวจสอบอีกครั้ง เมื่อค่าบูลีนของเงื่อนไขกลายเป็นเท็จ การวนซ้ำจะสิ้นสุดลง

ตัวอย่าง

// การหรี่ไฟ LED โดยใช้พิน PWM int PWMpin = 10; // LED อนุกรมพร้อมตัวต้านทาน 470 โอห์มสำหรับ 10 พิน การตั้งค่าเป็นโมฆะ() ( // ไม่จำเป็นต้องตั้งค่า) void loop() ( สำหรับ (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

วงจร สำหรับ C มีความยืดหยุ่นมากกว่าลูปมาก สำหรับในภาษาโปรแกรมอื่นๆ เช่น BASIC องค์ประกอบส่วนหัวใดๆ หรือทั้งสามรายการอาจละเว้นได้ แม้ว่าจะต้องใช้เครื่องหมายอัฒภาคก็ตาม นอกจากนี้ คำสั่งการเริ่มต้นแบบวนซ้ำ แบบมีเงื่อนไข และคำสั่งเพิ่มอาจเป็นคำสั่ง C ที่ถูกต้องใดๆ ที่มีตัวแปรอิสระ และใช้ประเภทข้อมูล C ใดๆ รวมถึงการลอยตัว สิ่งเหล่านี้ไม่ปกติสำหรับวงจรนี้ สำหรับ ประเภทตัวดำเนินการทำให้สามารถจัดหาโซลูชันซอฟต์แวร์สำหรับปัญหาที่ไม่ได้มาตรฐานบางประการได้

ตัวอย่างเช่น การใช้การคูณในตัวดำเนินการตัวนับลูปช่วยให้คุณสร้างความก้าวหน้าแบบลอการิทึมได้:

สำหรับ(int x = 2; x< 100; x = x * 1.5){ println(x); }

สร้างแล้ว: 2,3,4,6,9,13,19,28,42,63,94

อีกตัวอย่างหนึ่งคือการลดหรือเพิ่มระดับสัญญาณเป็น LED อย่างราบรื่นโดยใช้หนึ่งรอบ สำหรับ:

โมฆะวนรอบ ()) ( int x = 1; สำหรับ (int i = 0; i > -1; i = i + x) (analogWrite (PWMpin, i); ถ้า (i == 255) x = -1; / / การควบคุมการสลับที่ความล่าช้าสูงสุด (10); ) )

ออกแบบ สำหรับใช้เพื่อทำซ้ำบล็อกคำสั่งที่อยู่ในวงเล็บปีกกา โดยทั่วไปตัวนับการเพิ่มจะใช้เพื่อเพิ่มและยุติการวนซ้ำ ผู้ดำเนินการ สำหรับเหมาะสำหรับกิจกรรมที่เกิดซ้ำๆ และมักใช้ร่วมกับอาร์เรย์รวบรวมข้อมูล/เอาต์พุต

ส่วนหัวของห่วง สำหรับประกอบด้วยสามส่วน:

สำหรับ (การเริ่มต้น ; เงื่อนไข ; เพิ่มขึ้น) (ตัวดำเนินการดำเนินการในลูป)

การเริ่มต้นจะดำเนินการในครั้งแรกและครั้งเดียวเท่านั้น แต่ละครั้งในลูป จะมีการตรวจสอบเงื่อนไข หากเป็นจริง จะมีการดำเนินการบล็อกของคำสั่งและส่วนเพิ่ม จากนั้นเงื่อนไขจะถูกตรวจสอบอีกครั้ง เมื่อค่าบูลีนของเงื่อนไขกลายเป็นเท็จ การวนซ้ำจะสิ้นสุดลง

ตัวอย่าง

// การหรี่ไฟ LED โดยใช้พิน PWM int PWMpin = 10; // LED อนุกรมพร้อมตัวต้านทาน 470 โอห์มสำหรับ 10 พิน การตั้งค่าเป็นโมฆะ() ( // ไม่จำเป็นต้องตั้งค่า) void loop() ( สำหรับ (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

วงจร สำหรับ C มีความยืดหยุ่นมากกว่าลูปมาก สำหรับในภาษาโปรแกรมอื่นๆ เช่น BASIC องค์ประกอบส่วนหัวใดๆ หรือทั้งสามรายการอาจละเว้นได้ แม้ว่าจะต้องใช้เครื่องหมายอัฒภาคก็ตาม นอกจากนี้ คำสั่งการเริ่มต้นแบบวนซ้ำ แบบมีเงื่อนไข และคำสั่งเพิ่มอาจเป็นคำสั่ง C ที่ถูกต้องใดๆ ที่มีตัวแปรอิสระ และใช้ประเภทข้อมูล C ใดๆ รวมถึงการลอยตัว สิ่งเหล่านี้ไม่ปกติสำหรับวงจรนี้ สำหรับ ประเภทตัวดำเนินการทำให้สามารถจัดหาโซลูชันซอฟต์แวร์สำหรับปัญหาที่ไม่ได้มาตรฐานบางประการได้

ตัวอย่างเช่น การใช้การคูณในตัวดำเนินการตัวนับลูปช่วยให้คุณสร้างความก้าวหน้าแบบลอการิทึมได้:

สำหรับ(int x = 2; x< 100; x = x * 1.5){ println(x); }

สร้างแล้ว: 2,3,4,6,9,13,19,28,42,63,94

อีกตัวอย่างหนึ่งคือการลดหรือเพิ่มระดับสัญญาณเป็น LED อย่างราบรื่นโดยใช้หนึ่งรอบ สำหรับ:

โมฆะวนรอบ () ( int x = 1; สำหรับ (int i = 0; i > -1; i = i + x) (analogWrite (PWMpin, i); ถ้า (i == 255) x = -1; // การควบคุมการสลับที่ความล่าช้าสูงสุด (10); ) )

" เราได้เรียนรู้วิธีใช้ลูป "for" เพื่อจัดระเบียบการทำงานของคอนโทรลเลอร์ การวนซ้ำประเภทนี้ใช้ทุกที่และมากกว่าการครอบคลุม "ความจำเป็นในการดำเนินการวนซ้ำ" อย่างไรก็ตาม มีการวนซ้ำอีกประเภทหนึ่ง - "ในขณะที่" มันไม่ได้ดีไปกว่า for loop เพียงแต่ใช้หลักการที่แตกต่างกัน

ในกรณีส่วนใหญ่ คุณสามารถเลือกได้ว่าจะใช้ลูปประเภทใดจากสองประเภท ในเราใช้ " while" เพื่อหยุดโปรแกรมชั่วคราวจนกว่าผู้ใช้จะป้อนข้อมูลที่ต้องการ ในบทนี้ เราจะมาดูอย่างใกล้ชิดว่าลูปนี้ทำงานอย่างไรโดยใช้แพลตฟอร์ม Arduino เป็นตัวอย่าง

เรามาทำงานกับวงจรต่อไปซึ่งประกอบด้วยไฟ LED 2 ดวง

นอกจากนี้ เราจะยังคงทำงานกับโค้ดที่เราสรุปไว้ในบทที่ 14 ต่อไป

ย้อนกลับไปในอดีต: คอนโทรลเลอร์จะแจ้งให้ผู้ใช้ใส่ข้อมูลรออินพุตจากนั้นกำหนดค่าผลลัพธ์ให้กับตัวแปร กะพริบหมายเลขสีเขียวและ กะพริบหมายเลขสีแดง. ซึ่งจะทำให้ผู้ใช้สามารถควบคุมจำนวนครั้งที่ไฟ LED 2 ดวงแต่ละดวงจะกะพริบ

หากต้องการขยายมุมมองของโปรแกรมเมอร์คุณควรเรียนรู้ที่จะใช้ลูปสองประเภทเพื่อใช้งานเดียวกันและในอนาคตคุณสามารถแสดงความเห็นอกเห็นใจต่อประเภทใดประเภทหนึ่งได้

มาดูกันว่ามันทำงานอย่างไร:

ภายใน z= 1 ; // ประกาศตัวแปรและกำหนดค่าให้เป็น 1

ในขณะที่ (z<=10) { //запускаем цикл ในขณะที่

อนุกรม. พิมพ์(z); //ส่งออกค่าปัจจุบันของตัวแปรz ผ่านทางพอร์ตอนุกรม

z= z+1 // เพิ่มค่าของตัวแปรzโดย 1

) // จบการวนซ้ำ

while loop จะดำเนินการคำสั่งต่อไปตราบใดที่ “เงื่อนไข” ที่อธิบายไว้ในวงเล็บเป็นจริง ในตัวอย่างด้านบน ลูปจะดำเนินการคำสั่งต่อไปตราบใดที่ z น้อยกว่าหรือเท่ากับ 10 เนื้อความของลูปจะดำเนินการ 2 คำสั่ง:

• ส่งออกค่าของตัวแปรผ่านพอร์ตอนุกรม
• การเพิ่มค่าของตัวแปรขึ้น 1 (เรียกตามหลักวิทยาศาสตร์ว่าการเพิ่มขึ้น)

โดยการเพิ่มค่าของตัวแปร โปรแกรมจะออกจากลูปในที่สุด หากเราจินตนาการสักครู่ว่าเราลืมระบุบรรทัดนี้หรือมีข้อผิดพลาดเกิดขึ้น โปรแกรมก็จะเข้าสู่ลูปอย่างมีความสุข (กล่าวคือ มันจะค้าง)

ลูปเริ่มทำงานโดยการตรวจสอบความจริงของเงื่อนไข ถ้า z น้อยกว่าหรือเท่ากับ 10 โปรแกรมจะรันลูป จากนั้นตรวจสอบสภาพอีกครั้ง ฯลฯ เมื่อค่าของตัวแปรถึง z = 11 เงื่อนไขจะไม่เป็นจริงอีกต่อไป โปรแกรมจะไม่รันลูปและจะไปยังบรรทัดถัดไปทันทีหลังจากวงเล็บปีกกาของลูป

ทฤษฎีพอแล้ว เรามาฝึกฝนกันต่อ ลองแทนที่ for loops ในซอร์สโค้ดด้วย while loops

Flasher ดำเนินการโดยวงจร FOR:

สำหรับ (int i = 1; i<= blinkNumberGreen; i++) // ปล่อย วงจรสำหรับ

{

อนุกรม. พิมพ์("เขียววาบ");

Serial.println(i);

digitalWrite (greenLed, สูง); //เปิด สีเขียว ไดโอดเปล่งแสง

ล่าช้า (timeOnGreenLed); //พวกเรารอ

digitalWrite (greenLed, ต่ำ); //ปิด สีเขียว ไดโอดเปล่งแสง

ล่าช้า (timeOffGreenLed); //พวกเรารอ

}

ไฟกะพริบในรอบ WHILE:

ภายใน ฉัน=1; //ประกาศตัวแปรและกำหนดค่าเป็น 1

ขณะที่ฉัน<= blinkNumberGreen)

{ // ปล่อย วงจรในขณะที่

อนุกรม.พิมพ์("สีเขียว กระพริบตา «);

Serial.println(i);

digitalWrite (greenLed สูง); //เปิด สีเขียว ไดโอดเปล่งแสง

ล่าช้า (timeOnGreenLed); //พวกเรารอ

digitalWrite (greenLed, ต่ำ); //ปิด สีเขียว ไดโอดเปล่งแสง

ล่าช้า (timeOffGreenLed); //พวกเรารอ

ฉัน= ฉัน+1 //เพิ่มค่าของตัวแปร 1

}

บันทึกโปรแกรมและโหลดเฟิร์มแวร์ลงในคอนโทรลเลอร์ มาดูผลลัพธ์กันดีกว่า

วนซ้ำโดยใช้คำสั่ง สำหรับและ ในขณะที่เป็นหนึ่งในโครงสร้างที่สำคัญที่สุดของภาษา C++ ที่รองรับ Arduino พบได้ในทุกภาพร่าง แม้ว่าคุณจะไม่รู้ก็ตาม ในบทความนี้ เราจะมาดูลูปต่างๆ อย่างละเอียดยิ่งขึ้น ค้นหาว่าอะไรคือความแตกต่างระหว่าง for และ while คุณจะทำให้การเขียนโปรแกรมง่ายขึ้นด้วยความช่วยเหลือของพวกเขาได้อย่างไร และข้อผิดพลาดใดบ้างที่ควรหลีกเลี่ยง

หากคุณยังคงเป็นโปรแกรมเมอร์มือใหม่และต้องการเข้าใจว่าลูปคืออะไรและเหตุใดจึงจำเป็น โปรดดูส่วนถัดไปของบทความนี้พร้อมคำอธิบายโดยละเอียด

ตัวดำเนินการ WHILE ใช้ใน C++ และ Arduino เพื่อทำซ้ำคำสั่งเดียวกันตามจำนวนครั้งที่ต้องการ เมื่อเปรียบเทียบกับการวนซ้ำ FOR แล้ว การวนซ้ำ WHILE ดูง่ายกว่า โดยปกติจะใช้โดยที่เราไม่จำเป็นต้องนับจำนวนการวนซ้ำในตัวแปร แต่เพียงแค่ต้องทำซ้ำโค้ดจนกว่าจะมีการเปลี่ยนแปลงหรือมีเหตุการณ์บางอย่างเกิดขึ้น

ในขณะที่ไวยากรณ์

ในขณะที่(<условие или список условий>)
{
<программный блок, который будет повторяться>
}

โครงสร้างภาษาใดๆ ที่ส่งกลับค่าบูลีนสามารถใช้เป็นเงื่อนไขได้ เงื่อนไขอาจเป็นการดำเนินการเปรียบเทียบ ฟังก์ชัน ค่าคงที่ ตัวแปร เช่นเดียวกับการดำเนินการเชิงตรรกะอื่นๆ ใน Arduino ค่าใดๆ ที่ไม่ใช่ศูนย์จะถูกมองว่าเป็นจริง ศูนย์ – เท็จ

// การวนซ้ำไม่รู้จบ while(true)( Serial.println("Waiting..."); ) // การวนซ้ำที่รันจนกระทั่งค่าของฟังก์ชัน checkSignal() เปลี่ยนไปในขณะที่(!checkSignal())( Serial.println ("ซึ่งรอคอย..."); )

โปรดทราบว่าสามารถใช้คำสั่ง while ได้โดยไม่ต้องบล็อกบล็อกด้วยเครื่องหมายปีกกา ในกรณีนี้ คำสั่งแรกที่พบหลังจากการวนซ้ำจะถูกทำซ้ำ ไม่แนะนำให้ใช้ในขณะที่ไม่มีเหล็กดัดฟันเพราะว่า ในกรณีนี้มันง่ายมากที่จะทำผิดพลาด ตัวอย่าง:

ในขณะที่ (จริง) Serial.print ("กำลังรอการหยุดชะงัก"); ล่าช้า (1,000);

ในกรณีนี้ คำจารึกจะแสดงวนซ้ำไม่สิ้นสุดโดยไม่หยุดชั่วคราว เนื่องจากคำสั่งหน่วงเวลา (1000) จะไม่ถูกทำซ้ำ คุณสามารถใช้เวลามากมายในการค้นหาข้อผิดพลาดดังกล่าว - การใช้วงเล็บปีกกานั้นง่ายกว่ามาก

ตัวอย่างการใช้งาน ในขณะที่วนซ้ำ

โดยส่วนใหญ่ while ใช้เพื่อรอเหตุการณ์บางอย่าง ตัวอย่างเช่นความพร้อมของวัตถุอนุกรมในการทำงาน

อนุกรมเริ่มต้น(9600); ในขณะที่ (!Serial) ( ; // บอร์ด Arduino บางรุ่นต้องการให้คุณรอจนกว่าพอร์ตอนุกรมจะว่าง)

ตัวอย่างการรอให้อักขระมาถึงจากอุปกรณ์ภายนอกผ่าน UART:

ในขณะที่ (Serial.available())( int byteInput = Seria.read(); // การกระทำอื่น ๆ บางอย่าง)

ในกรณีนี้ เราจะอ่านค่าตราบใดที่ Serial.available() ส่งกลับค่าที่ไม่ใช่ศูนย์ เมื่อข้อมูลทั้งหมดในบัฟเฟอร์หมด การวนซ้ำจะหยุดลง

สำหรับลูปใน Arduino

ในวง FOR เรามีโอกาสไม่เพียงแค่กำหนดเงื่อนไขขอบเขตเท่านั้น แต่ยังกำหนดตัวแปรสำหรับตัวนับได้ทันทีและระบุว่าค่าจะเปลี่ยนแปลงอย่างไรในการวนซ้ำแต่ละครั้ง

สำหรับไวยากรณ์ลูป

การออกแบบจะซับซ้อนกว่านี้เล็กน้อย:
สำหรับ (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

ตัวอย่างที่ง่ายที่สุด:

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

เราสร้างตัวแปรทันที เริ่มต้นมัน และระบุว่าเมื่อสิ้นสุดแต่ละรอบ ค่าตัวนับควรเพิ่มขึ้นหนึ่ง เพียงเท่านี้คุณก็สามารถใช้ตัวแปรภายในลูปได้แล้ว

ขั้นตอนของตัวแปรอาจแตกต่างกัน นี่คือตัวอย่าง:

• สำหรับ(int i=0; i<10; i=i+2) // Шаг 2
• สำหรับ(int i=0; i<10; i+=2) // Аналогичен предыдущему
• for(int i=10; i>0; i–) // ย้อนกลับ – จาก 10 เป็น 1

ทำในขณะที่วนซ้ำ

ในบางกรณี เราจำเป็นต้องจัดระเบียบลูปในลักษณะที่คำสั่งของบล็อกถูกดำเนินการอย่างน้อยหนึ่งครั้ง จากนั้นจึงทำการตรวจสอบ สำหรับอัลกอริธึมดังกล่าว คุณสามารถใช้ do while build ได้ ตัวอย่าง:

ทำ ( Serial.println("Working"); ) while (checkSomething());

การวนซ้ำเวอร์ชันนี้ไม่มีปัญหาใดๆ - เราเพียงแค่ย้ายบล็อกโดยมีเงื่อนไขลดลง ดังนั้นเนื้อหาทั้งหมดที่อยู่ในวงเล็บปีกกาหลังจากตัวดำเนินการ do จะถูกดำเนินการก่อนการตรวจสอบครั้งแรก

ดำเนินการต่อและทำลายคำสั่ง

มีสถานการณ์ต่างๆ ที่คุณจำเป็นต้องขัดจังหวะการดำเนินการของลูปภายในบล็อกลูปอย่างเร่งด่วน โดยไม่ต้องรอไปยังบล็อกตรวจสอบเงื่อนไข ในการทำเช่นนี้คุณสามารถใช้โอเปอเรเตอร์ได้ หยุดพัก:

ในขณะที่ (จริง) ( ​​ถ้า (checkSomething()) ( แบ่ง; ) )

หากเราเพียงต้องการหยุดความคืบหน้าของการวนซ้ำปัจจุบัน แต่ไม่ออกจากลูป แต่ไปที่บล็อกการตรวจสอบเงื่อนไข เราต้องใช้ตัวดำเนินการ ดำเนินการต่อ:

ในขณะที่ (จริง) ( ​​ถ้า (checkSomething()) ( ดำเนินการต่อ; ) )

คำสั่ง Continue และ Break สามารถใช้ได้กับลูป FOR และ WHILE ทุกรูปแบบ

ลูปที่ซ้อนกันใน Arduino

ลูปแบบต่างๆ สามารถรวมเข้าด้วยกันได้อย่างง่ายดาย ทำให้เกิดโครงสร้างที่ซ้อนกัน ตัวแปรที่กำหนดไว้ในบล็อกของลูป "ซ้อนทับ" จะมีอยู่ในลูปด้านใน ตัวอย่างที่พบบ่อยที่สุดของการวนซ้ำประเภทนี้คือการข้ามอาร์เรย์สองมิติ ในตัวอย่างต่อไปนี้ เราใช้การวนซ้ำสองครั้ง: อันแรกจะวนซ้ำผ่านแถว (ตัวแปร i) ส่วนอันที่สองที่ซ้อนกันจะวนซ้ำผ่านคอลัมน์ (ตัวแปร j) ของอาร์เรย์ ซึ่งเรากำหนดไว้ในตัวแปร arr

อินท์อาร์; การตั้งค่าเป็นโมฆะ () ( สำหรับ (int i = 0; i< 10; i++) { for (int j = 0; j < 3; j++) { arr[i][j] = i * j; Serial.println(arr[i][j]); } } }

ข้อมูลเพิ่มเติมเกี่ยวกับรอบ

หากคุณไม่เคยทำงานกับลูปมาก่อน มาดำดิ่งสู่โลกแห่งทฤษฎีสักหน่อย แล้วดูว่าลูปคืออะไร และทำไมเราถึงต้องการโครงสร้างภาษาลึกลับเหล่านี้

ทำไมเราต้องมีวง?

ที่จริงแล้ว งานหลักของลูปคือการทำซ้ำโครงสร้างภาษาเดียวกันหลายครั้ง ความต้องการนี้เกิดขึ้นในเกือบทุกโปรแกรม และแน่นอนว่าไม่มีร่าง Arduino ตัวเดียวที่สามารถทำได้หากไม่มีการวนซ้ำ - ฟังก์ชัน loop() เรียกอีกอย่างว่าการวนซ้ำไม่สิ้นสุด

ลองดูตัวอย่างต่อไปนี้ คุณต้องจ่ายไฟพร้อมกันให้กับ LED 5 ดวงที่เชื่อมต่อกับบอร์ด Arduino จากพิน 5 ถึง 9 ตัวเลือกที่ชัดเจนที่สุดสำหรับสิ่งนี้คือการวางคำสั่งห้าคำสั่งติดต่อกัน:

digitalWrite (5, สูง);

digitalWrite (6, สูง);

digitalWrite (7, สูง);

digitalWrite (8, สูง);

digitalWrite (9, สูง);

ตอนนี้เราอย่าสนใจประเด็นความเสี่ยงของการกระทำดังกล่าวเนื่องจากการรวม LED จำนวนดังกล่าวพร้อมกันทำให้เกิดภาระที่เพิ่มขึ้นในวงจรไฟฟ้าของบอร์ด สิ่งสำคัญสำหรับเราในตอนนี้คือเราได้สร้างโค้ดขึ้นมาห้าบรรทัด ซึ่งแต่ละบรรทัดแตกต่างจากโค้ดอื่นๆ เพียงหลักเดียวเท่านั้น วิธีนี้มีข้อเสียดังต่อไปนี้:

• เมื่อมีการเปลี่ยนแปลงใดๆ คุณจะต้องทำการเปลี่ยนแปลงหลายบรรทัดพร้อมกัน ตัวอย่างเช่น หากเราต้องเปลี่ยน LED ไปที่พิน 2 ถึง 6 หรือปิดแรงดันไฟฟ้าแทนที่จะเปิด เราจะต้องทำการเปลี่ยนแปลงโค้ด 5 ครั้ง จะเกิดอะไรขึ้นหากมีคำแนะนำและการเปลี่ยนแปลงเพิ่มเติม
• โค้ดขนาดใหญ่ที่มีคำแนะนำที่คล้ายกันจำนวนมากทำให้อ่านไม่สะดวกและไม่น่าพอใจ ห้าบรรทัดที่เหมือนกันไม่น่ากลัวมาก แต่นิสัยชอบเขียนโค้ดสกปรกในที่สุดจะนำไปสู่หน้าพิเศษหลายสิบหรือหลายร้อยหน้าในรายการ ซึ่งจะทำให้คุณและเพื่อนร่วมงานรู้สึกท้อแท้
• ในกระบวนการ "คัดลอก-วาง" คำสั่งที่เกือบจะเหมือนกัน คุณสามารถทำผิดพลาดได้อย่างง่ายดาย เช่น ลืมเปลี่ยนหมายเลขพิน: digitalWrite(5, HIGH); digitalWrite (5, สูง);
• คุณสามารถล้มเหลวในการสัมภาษณ์ที่บริษัทซอฟต์แวร์ทั่วไปได้อย่างง่ายดายโดยแสดงรหัสนี้ให้ผู้สัมภาษณ์เห็น

จากทั้งหมดนี้ เราสามารถสรุปได้ว่าการใช้สตริงเดิมซ้ำแล้วซ้ำอีกควรหลีกเลี่ยงและแทนที่ด้วยลูปเกือบทุกครั้ง ยิ่งไปกว่านั้น ในหลาย ๆ สถานการณ์ เป็นไปไม่ได้ที่จะทำโดยไม่มีวงจรและไม่มีอะไรสามารถแทนที่วงจรเหล่านั้นได้ คุณไม่สามารถเปลี่ยนจำนวนครั้งที่รหัสถูกทำซ้ำในขณะที่โปรแกรมกำลังทำงานอยู่ ตัวอย่างเช่น คุณต้องประมวลผลแต่ละองค์ประกอบ อาร์เรย์ข้อมูลที่ได้รับจากอุปกรณ์ภายนอก คุณจะไม่คาดเดาได้ว่าจะมีข้อมูลจำนวนเท่าใด การประมวลผลซ้ำกี่ครั้ง ดังนั้น คุณจะไม่สามารถแทรกคำแนะนำตามจำนวนที่ต้องการในขณะที่เขียนบทความได้

และที่นี่มีวงจรมาช่วยเรา

กฎไวยากรณ์

วนซ้ำใน Arduinoเป็นบล็อกโปรแกรมพิเศษที่จะถูกเรียกเป็นจำนวนครั้งระหว่างการทำงานของโปรแกรม ภายในบล็อกนี้ เราจะอธิบายคำสั่งที่จะถูกเรียกใช้และกฎที่คอนโทรลเลอร์จะกำหนดจำนวนครั้งที่จะต้องเรียกใช้

ในตัวอย่างข้างต้น เราสามารถบอกคอนโทรลเลอร์ได้ดังต่อไปนี้:

ทำซ้ำคำสั่ง digitalWrite 5 ครั้ง

ในโลกอุดมคติที่มีโปรแกรมเมอร์หุ่นยนต์ นี่อาจจะเพียงพอแล้ว แต่เนื่องจากเรากำลังพูดคุยกับคอมพิวเตอร์ในภาษา C++ เราจึงต้องแปลวลีนี้เป็นภาษานี้:

ทำซ้ำคำสั่ง – คุณต้องใช้คำสั่งพิเศษที่บอกคอนโทรลเลอร์ว่าสิ่งที่น่าสนใจกำลังจะเริ่มต้นด้วย while หรือ for loops

ดิจิทัลเขียน – ปล่อยไว้เหมือนเดิม แต่เขียนครั้งเดียวแล้วใส่เครื่องหมายปีกกา จะทำอย่างไรกับหมายเลขพิน - ด้านล่าง

5 ครั้ง – ใช้ตัวนับสำหรับสิ่งนี้ ซึ่งจะเพิ่มขึ้นทุกครั้งที่ทำซ้ำ ที่จุดเริ่มต้น (หรือสิ้นสุด) ของบล็อก คุณสามารถเปรียบเทียบค่าของตัวนับนี้กับค่าขีดจำกัด (ในกรณีนี้คือ 5) โดยใช้การดำเนินการเปรียบเทียบ

ลองดูตัวอย่างคำสั่งลูป "translated" พร้อมด้วยคำสั่ง while:

ตัวนับ Int = 0; // ตัวแปรที่จะเก็บค่าตัวนับ // เราขอให้โปรเซสเซอร์ทำซ้ำโครงสร้างในเครื่องหมายปีกกาจนกว่าเงื่อนไขในวงเล็บจะคืนค่าเป็นจริง // ในกรณีของเรา ตัวนับคือตัวนับของเรา 5 คือค่าจำกัด เงื่อนไขคือค่าตัวนับน้อยกว่า 5 // แต่เราสามารถระบุตัวดำเนินการเชิงตรรกะที่แตกต่างกันโดยสิ้นเชิงในขณะที่ (ตัวนับ< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

สำหรับผู้ที่สังเกตเห็นข้อผิดพลาดในโค้ดที่กำหนด เราจะให้ห้าข้อและเขียน loop block แตกต่างออกไป:

ในขณะที่(เคาน์เตอร์< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

ผลลัพธ์เดียวกันนี้สามารถทำได้โดยใช้ FOR loop:

สำหรับ(int counter =0; counter<5; counter ++){ digitalWrite(counter+5, HIGH); }

อย่างที่คุณเห็นในกรณีนี้เราจะรวมการดำเนินการที่จำเป็นทั้งหมดพร้อมตัวนับไว้ในคำสั่งเดียวทันทีซึ่งสะดวกกว่ามากหากคุณต้องการนับจำนวนที่ต้องการ

คุณสามารถรับข้อมูลโดยละเอียดเกี่ยวกับกฎการใช้ลูปได้ในส่วนที่เกี่ยวข้องของบทความนี้

บทสรุป

ในบทความนี้ เราได้ดูโครงสร้างที่สำคัญมากของภาษา Arduino: FOR และ WHILE loops คุณสามารถค้นหาโอเปอเรเตอร์เหล่านี้ได้ในภาพร่างที่ซับซ้อนไม่มากก็น้อย เนื่องจากหากไม่มีการวนซ้ำ การดำเนินการกับข้อมูลจำนวนมากจะเป็นไปไม่ได้ ไวยากรณ์ของลูปไม่มีอะไรซับซ้อน - คุณสามารถทำความคุ้นเคยได้อย่างง่ายดายและสามารถนำไปใช้ในโครงการของคุณได้

/ /

สำหรับผู้ปฏิบัติงาน

ออกแบบ สำหรับใช้เพื่อทำซ้ำบล็อกคำสั่งที่อยู่ในวงเล็บปีกกา โดยทั่วไปตัวนับการเพิ่มจะใช้เพื่อเพิ่มและยุติการวนซ้ำ ผู้ดำเนินการ สำหรับเหมาะสำหรับกิจกรรมที่เกิดซ้ำๆ และมักใช้ร่วมกับอาร์เรย์รวบรวมข้อมูล/เอาต์พุต

ส่วนหัวของห่วง สำหรับประกอบด้วยสามส่วน:

สำหรับ (การเริ่มต้น; เงื่อนไข; เพิ่มขึ้น) (ตัวดำเนินการดำเนินการในลูป)

การเริ่มต้นจะดำเนินการในครั้งแรกและครั้งเดียวเท่านั้น แต่ละครั้งในลูป จะมีการตรวจสอบเงื่อนไข หากเป็นจริง จะมีการดำเนินการบล็อกของคำสั่งและส่วนเพิ่ม จากนั้นเงื่อนไขจะถูกตรวจสอบอีกครั้ง เมื่อค่าบูลีนของเงื่อนไขกลายเป็นเท็จ การวนซ้ำจะสิ้นสุดลง

ตัวอย่าง

// การหรี่ไฟ LED โดยใช้พิน PWM int PWMpin = 10; // LED อนุกรมพร้อมตัวต้านทาน 470 โอห์มสำหรับ 10 พิน การตั้งค่าเป็นโมฆะ() ( // ไม่จำเป็นต้องตั้งค่า) void loop() ( สำหรับ (int i=0; i<= 255; i++){ analogWrite(PWMpin, i); delay(10); } }

วงจร สำหรับ C มีความยืดหยุ่นมากกว่าลูปมาก สำหรับในภาษาโปรแกรมอื่นๆ เช่น BASIC องค์ประกอบส่วนหัวใดๆ หรือทั้งสามรายการอาจละเว้นได้ แม้ว่าจะต้องใช้เครื่องหมายอัฒภาคก็ตาม นอกจากนี้ คำสั่งการเริ่มต้นแบบวนซ้ำ แบบมีเงื่อนไข และคำสั่งเพิ่มอาจเป็นคำสั่ง C ที่ถูกต้องใดๆ ที่มีตัวแปรอิสระ และใช้ประเภทข้อมูล C ใดๆ รวมถึงการลอยตัว สิ่งเหล่านี้ไม่ปกติสำหรับวงจรนี้ สำหรับประเภทตัวดำเนินการทำให้สามารถจัดหาโซลูชันซอฟต์แวร์สำหรับปัญหาที่ไม่ได้มาตรฐานบางประการได้

ตัวอย่างเช่น การใช้การคูณในตัวดำเนินการตัวนับลูปช่วยให้คุณสร้างความก้าวหน้าแบบลอการิทึมได้:

สำหรับ(int x = 2; x< 100; x = x * 1.5){ println(x); }

สร้างแล้ว: 2,3,4,6,9,13,19,28,42,63,94

อีกตัวอย่างหนึ่งคือการลดหรือเพิ่มระดับสัญญาณเป็น LED อย่างราบรื่นโดยใช้หนึ่งรอบ สำหรับ:

โมฆะวนรอบ ()) ( int x = 1; สำหรับ (int i = 0; i > -1; i = i + x) (analogWrite (PWMpin, i); ถ้า (i == 255) x = -1; / / การควบคุมการสลับที่ความล่าช้าสูงสุด (10); ) )