Arduino วนซ้ำ FOR และ WHILE วนซ้ำใน Arduino วนซ้ำซ้อนใน Arduino

• ในขณะที่ (เงื่อนไข) ()

• ทำ() ในขณะที่ (เงื่อนไข);

• for(ตัวแปรนับ; เงื่อนไข; เพิ่มตัวแปรนับ) ()

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

Arduino IDE ยืมการควบคุมที่จำเป็นส่วนใหญ่จาก C/C++ ไวยากรณ์ของพวกเขาเหมือนกันกับ C ด้านล่างนี้เราจะอธิบายไวยากรณ์โดยย่อ

ถ้าคำสั่ง

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

ถ้า(เงื่อนไข) ( Instruction1; Instruction2; )

เงื่อนไขอาจเป็นการเปรียบเทียบตัวแปรหรือค่าที่ส่งคืนโดยฟังก์ชัน เกณฑ์หลักสำหรับเงื่อนไข if คือคำตอบจะต้องเป็นจริงหรือเท็จเสมอ ตัวอย่างเงื่อนไขของคำสั่ง if:

ถ้า(a!=2) ( ) ถ้า(x<10) { } if(znak==’B’) { }

ภายในวงเล็บที่เขียนไว้ในเงื่อนไข คุณสามารถรันโค้ดได้

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

คุณสามารถใช้สถานะฟังก์ชันเป็นเงื่อนไขได้ เช่น

ถ้า(init()) ( Serial.print("ok"); )

ตัวอย่างข้างต้นจะถูกดำเนินการดังนี้: ในขั้นตอนแรก ฟังก์ชัน init() จะถูกเรียก ฟังก์ชันนี้ส่งคืนค่าที่จะตีความว่าเป็น "จริง" หรือ "เท็จ" ขึ้นอยู่กับผลการเปรียบเทียบ ข้อความ "ตกลง" จะถูกส่งหรือไม่ส่งอะไรเลย

ถ้า...คำสั่งอื่น

คำสั่ง if แบบขยายคือคำสั่ง if….else ช่วยให้มั่นใจได้ว่าโค้ดชิ้นหนึ่งจะถูกดำเนินการเมื่อเงื่อนไขเป็นจริง (จริง) และโค้ดชิ้นที่สองจะถูกดำเนินการเมื่อไม่ตรงตามเงื่อนไข (เท็จ) ไวยากรณ์ของคำสั่ง f if….else เป็นดังนี้:

ถ้า (เงื่อนไข) ( // คำสั่ง A ) อื่น ( // คำสั่ง B )

คำสั่ง "A" จะถูกดำเนินการเมื่อตรงตามเงื่อนไขเท่านั้น คำสั่ง "B" จะถูกดำเนินการเมื่อไม่ตรงตามเงื่อนไข ไม่สามารถดำเนินการคำสั่ง "A" และ "B" พร้อม ๆ กันได้ ตัวอย่างต่อไปนี้แสดงวิธีใช้ไวยากรณ์ if...else:

ถ้า (init()) ( Serial.print("ok"); ) else ( Serial.print("error"); )

ด้วยวิธีนี้ คุณสามารถตรวจสอบการทำงานที่ถูกต้องของฟังก์ชันและแจ้งให้ผู้ใช้ทราบได้

แนวทางปฏิบัติทั่วไปคือการปฏิเสธเงื่อนไข เนื่องจากฟังก์ชันที่ดำเนินการอย่างถูกต้องจะส่งกลับค่า 0 และฟังก์ชันที่ดำเนินการไม่ถูกต้องด้วยเหตุผลบางประการจะส่งกลับค่าที่ไม่ใช่ศูนย์

คำอธิบายสำหรับ “ความซับซ้อนของชีวิต” นี้เป็นเรื่องง่าย หากฟังก์ชันดำเนินการอย่างถูกต้อง นี่เป็นข้อมูลเดียวที่เราต้องการ ในกรณีที่เกิดข้อผิดพลาด บางครั้งคุณควรทำความเข้าใจว่ามีอะไรผิดพลาดและเหตุใดฟังก์ชันจึงทำงานไม่ถูกต้อง และตัวเลขอื่นๆ ที่ไม่ใช่ศูนย์ก็เข้ามาช่วยเหลือ เช่น การใช้รหัสดิจิทัล เราสามารถระบุประเภทของข้อผิดพลาดได้ ตัวอย่างเช่น 1 - ปัญหาในการอ่านค่าบางค่า 2 - ไม่มีพื้นที่ในหน่วยความจำหรือบนดิสก์ ฯลฯ

ตัวอย่างที่แก้ไขล่าสุดแสดงวิธีการเรียกใช้ฟังก์ชันที่ส่งคืนศูนย์เมื่อดำเนินการอย่างถูกต้อง:

ถ้า (!init()) ( Serial.print("ok"); ) else ( Serial.print("error"); )

คำสั่งสลับกรณี

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

Switch (var) ( กรณีที่ 1: //คำสั่งสำหรับการแตก var=1; กรณีที่ 2: //คำสั่งสำหรับการแตก var=2; ค่าเริ่มต้น: //คำสั่งเริ่มต้น (ถ้า var แตกต่างจาก 1 และ 2) )

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

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

มันมักจะเกิดขึ้นที่ต้องใช้คำสั่งเดียวกันสำหรับค่าใดค่าหนึ่งจากหลายค่า สามารถทำได้ดังนี้:

Switch (x) ( กรณีที่ 1: //คำสั่งสำหรับการแตก x=1; กรณีที่ 2: กรณีที่ 3: กรณีที่ 5: //คำสั่งสำหรับการแตก x=2 หรือ 3 หรือ 4; กรณีที่ 4: //คำสั่งสำหรับการแตก x=4 ; กรณีที่ 6: // คำสั่งสำหรับการแตก x=6; ค่าเริ่มต้น: // คำสั่งเริ่มต้น (ถ้า x แตกต่างจาก 1,2,3,4,5,6) )

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

สำหรับคำสั่ง

คำสั่ง for ใช้ในการรันโค้ดเดิมซ้ำแล้วซ้ำอีก บ่อยครั้งที่จำเป็นต้องดำเนินการตามคำสั่งเดียวกัน โดยเปลี่ยนเฉพาะค่าของตัวแปรบางตัวเท่านั้น for loop เหมาะอย่างยิ่งสำหรับสิ่งนี้ ไวยากรณ์คำสั่งมีดังนี้:

ฉัน; สำหรับ(i=0;i<10;i++) { // инструкции для выполнения в цикле }

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

บ่อยครั้งที่มีการประกาศตัวแปรที่ใช้ในลูป:

สำหรับ(int i=0;i<10;i++) { // инструкции для выполнения в цикле }

ตัวแปรที่ใช้ในการนับขั้นตอนต่อมาของการวนซ้ำสามารถใช้ภายในเพื่อเรียกใช้ฟังก์ชันด้วยพารามิเตอร์ที่เหมาะสม

For(int i=10;i>0;i—) ( Serial.print(i); // ตัวเลข 10,9,8,7,6,5,4,3,2,1 จะถูกส่งไป)

ในขณะที่คำสั่ง

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

ในขณะที่ (เงื่อนไข) ( // บล็อกคำสั่งที่จะดำเนินการ)

สิ่งสำคัญคือการตรวจสอบสถานะจะต้องเกิดขึ้นเมื่อเริ่มต้นรอบการทำงาน อาจเกิดขึ้นได้ว่าคำสั่งภายใน while loop ไม่เคยถูกดำเนินการ สามารถสร้างวงวนไม่สิ้นสุดได้เช่นกัน ลองดูสองตัวอย่าง:

อินท์ x=2; ในขณะที่(x>5) ( Serial.print(x); ) —————————————- int y=5; ในขณะที่(y>0) ( Serial.print(y); )

บล็อกแรกของคำสั่งที่อยู่ภายใน while จะไม่ถูกดำเนินการ ตัวแปร x มีค่าเป็น 2 และจะไม่มากกว่า 5 ในตัวอย่างที่สอง เรากำลังจัดการกับการวนซ้ำไม่สิ้นสุด ตัวแปร “y” มีค่าเป็น 5 นั่นคือ มากกว่าศูนย์ ไม่มีการเปลี่ยนแปลงกับตัวแปร "y" ภายในลูป ดังนั้นการวนซ้ำจะไม่เสร็จสมบูรณ์

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

อินท์x=0; ในขณะที่(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

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

ทำ…ในขณะที่คำสั่ง

รูปแบบหนึ่งของ while loop คือ do... While loop นอกจากไวยากรณ์แล้ว ยังแตกต่างในตำแหน่งที่มีการตรวจสอบเงื่อนไขด้วย ในกรณีของ do... While เงื่อนไขจะถูกตรวจสอบหลังจากดำเนินการบล็อคคำสั่งแล้ว ซึ่งหมายความว่าบล็อกคำสั่งในส่วนเนื้อหาของลูปจะถูกดำเนินการอย่างน้อยหนึ่งครั้ง ด้านล่างนี้คือไวยากรณ์ของคำสั่ง do... While:

ทำ ( // บล็อกคำสั่ง) ในขณะที่ (เงื่อนไข)

ทุกสิ่งที่เขียนเกี่ยวกับตัวดำเนินการ while ยังใช้กับ do... while ได้ด้วย ด้านล่างนี้เป็นตัวอย่างของการใช้ do... While loop:

อินท์x=10; ทำ ( // บล็อกคำสั่ง x—; ) ในขณะที่(x>0); —————————————- do ( // block of Instruction if (condition) break; ) while(true);

คำสั่งแบ่ง

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

สำหรับ(i=0;i<10;i++) { if(i==5) break; Serial.print(i); }

จะต้องดำเนินการวนซ้ำสำหรับตัวเลข 0 ถึง 9 แต่สำหรับหมายเลข 5 จะต้องตรงตามเงื่อนไขที่ทำให้เกิดคำสั่งแบ่ง นี่จะเป็นการออกจากลูป เป็นผลให้เฉพาะตัวเลข 0,1,2,3,4 เท่านั้นที่จะถูกส่งไปยังพอร์ตอนุกรม (Serial.print)

ดำเนินการต่อ

ตัวดำเนินการดำเนินการต่อจะทำให้คำสั่งวนรอบ (ทำ...ในขณะที่, สำหรับ, ในขณะที่) หยุดการดำเนินการสำหรับค่าปัจจุบันและดำเนินการไปยังขั้นตอนการวนซ้ำถัดไป ตัวอย่างต่อไปนี้แสดงวิธีการทำงานของคำสั่ง Continue:

สำหรับ(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }

ตามที่สังเกตได้ไม่ยากลูปจะถูกดำเนินการสำหรับค่าตั้งแต่ 0 ถึง 9 สำหรับค่า 5 คำสั่ง Continue จะถูกดำเนินการซึ่งเป็นผลมาจากคำแนะนำหลังจากคำสั่งนี้จะไม่ถูกดำเนินการ ด้วยเหตุนี้ตัวเลข 0,1,2,3,4,6,7,8,9 จะถูกส่งไปยังพอร์ตอนุกรม (Serial.print)

คำสั่งส่งคืน

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

Int checkSensor())( if (analogRead(0) > 400) ( // อ่านอินพุตอะนาล็อกส่งคืน 1; // สำหรับค่าที่มากกว่า 400 จะส่งคืนค่า 1 มิฉะนั้น (ส่งคืน 0; // สำหรับค่าอื่น ๆ 0 คือ กลับมา))

อย่างที่คุณเห็น คุณสามารถใช้คำสั่ง return หลายคำสั่งในฟังก์ชันเดียวได้ แต่จะมีเพียงคำสั่งเดียวเท่านั้นที่จะใช้งานได้เสมอ อนุญาตให้ใช้ตัวดำเนินการส่งคืนโดยไม่มีพารามิเตอร์ได้ สิ่งนี้ทำให้คุณสามารถยุติฟังก์ชันที่ไม่ส่งคืนค่าใดๆ ก่อนเวลาอันควรได้

เป็นโมฆะ function_name() ( Instruction1; if(x==0) return; Instruction2; Instruction3; )

ในตัวอย่างข้างต้น Instruction1 จะดำเนินการทุกครั้งที่มีการเรียกใช้ฟังก์ชัน การดำเนินการของ Instruction2 และ Instruction3 ขึ้นอยู่กับผลลัพธ์ของคำสั่ง if หากเงื่อนไขเป็นจริง (จริง) คำสั่ง return จะถูกดำเนินการและฟังก์ชันจะออก

ในกรณีที่ไม่ตรงตามเงื่อนไข คำสั่ง return จะไม่ถูกดำเนินการเช่นกัน แต่คำสั่ง Instruction2 และ Instruction3 จะถูกดำเนินการ และหลังจากนั้นฟังก์ชันก็ทำงานเสร็จสิ้น

คำสั่งข้ามไป

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

…. ข้ามไปทำเครื่องหมาย; // ไปที่บรรทัดชื่อ 'metka' ..... .... …. metka: // ป้ายกำกับที่โปรแกรมจะทำงานต่อไป...

คำสั่งอนุญาตให้คุณไปที่เครื่องหมายที่กำหนดเช่น ไปยังตำแหน่งในโปรแกรม

วนซ้ำโดยใช้คำสั่ง สำหรับและ ในขณะที่เป็นหนึ่งในโครงสร้างที่สำคัญที่สุดของภาษา 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 loop

โดยส่วนใหญ่ 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 คุณสามารถค้นหาโอเปอเรเตอร์เหล่านี้ได้ในภาพร่างที่ซับซ้อนไม่มากก็น้อย เนื่องจากหากไม่มีการวนซ้ำ การดำเนินการกับข้อมูลจำนวนมากคงเป็นไปไม่ได้ ไวยากรณ์ของลูปไม่มีอะไรซับซ้อน - คุณสามารถทำความคุ้นเคยได้อย่างง่ายดายและสามารถนำไปใช้ในโครงการของคุณได้

มาดูกันว่าตัวดำเนินการลูป for, while และ do while ทำงานอย่างไรใน Arduino IDE วิธีใช้ลูปอย่างถูกต้องในภาพร่าง และข้อผิดพลาดที่ควรหลีกเลี่ยง เราจะสาธิตวิธีการหยุดลูปหรือย้ายจากลูปหนึ่งไปอีกลูปหนึ่งโดยใช้ตัวอย่างง่ายๆ เพื่อให้เข้าใจถึงความถูกต้องของวงจรการเขียน ก่อนอื่นคุณควรศึกษาประเภทและคุณสมบัติของอัลกอริธึมในวิทยาการหุ่นยนต์

ลูปทำงานอย่างไรใน Arduino IDE

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

หลักการทำงานของ for และ while สามารถอธิบายได้ด้วยตัวอย่างง่ายๆ ต่อไปนี้ for loop จะดำเนินการตามจำนวนครั้งที่จำกัด (ระบุในเงื่อนไขของผู้ปฏิบัติงาน) ซึ่งจะใช้เมื่อโปรแกรมต้องการให้ LED กระพริบหลายครั้ง ในขณะที่ลูปสามารถทำงานได้อย่างไม่มีที่สิ้นสุด ตัวอย่างเช่น เมื่อ LED บน Arduino กะพริบจนกว่าข้อมูลจากเซ็นเซอร์จะเปลี่ยนไป

คำอธิบายของ for loop ใน Arduino พร้อมตัวอย่าง

สำหรับการสร้างใน Arduino มีการกำหนดดังนี้:

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

ในตัวอย่างนี้ มีการตั้งค่าตัวแปรที่มีค่าเริ่มต้นไว้ ผม=0เงื่อนไขระบุว่าลูปจะทำงานจนกว่าตัวแปรจะเท่ากับหรือมากกว่าห้า ฉัน<=5 . การเปลี่ยนแปลงระบุว่าตัวแปรจะเพิ่มขึ้นทีละขั้นในแต่ละขั้นตอนของลูป สุดท้าย for ลูปจะออกเมื่อตัวแปรเท่ากับ 5 ดังนั้น LED จะกะพริบห้าครั้งก่อนที่ลูปจะสิ้นสุด

ขั้นตอนตัวแปร (การเปลี่ยนแปลง) สามารถเป็นอะไรก็ได้ หากจำเป็นต้องเพิ่มตัวแปรทีละสองหน่วยในคราวเดียว ควรเขียนการเปลี่ยนแปลงในตัวนับดังนี้: ผม=ผม+2. สามารถใช้ for loop ภายในขั้นตอนการตั้งค่า void ได้ เช่น เพื่อระบุโหมดการทำงานของพินหลายตัวพร้อมกัน และในขั้นตอนของ void loop เช่น ในโปรแกรมสำหรับการเปิด LED บน Arduino ตามลำดับ

คำอธิบายของ Arduino while loop พร้อมตัวอย่าง

โครงสร้าง while ใน Arduino มีการกำหนดดังนี้:

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

เมื่อใช้ฟังก์ชัน while จะต้องสร้างตัวแปรก่อนที่จะเริ่มการวนซ้ำ ในภาพร่างตัวอย่าง ไฟ LED จะกะพริบห้าครั้งก่อนสิ้นสุดรอบ หากคุณไม่เปลี่ยนตัวแปรภายในเครื่องหมายปีกกา ฉัน++แล้ววงจรก็จะเกิดซ้ำไม่สิ้นสุด วิธีที่สองในการออกจาก while ของ Arduino Uno คือการอ่านข้อมูลจากเซ็นเซอร์และใช้คำสั่ง if เพื่อเปลี่ยนตัวแปร

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

วิธีแยกออกจาก a while หรือ for loop

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