ไวยากรณ์ของ Arduino ภาษาการเขียนโปรแกรม Arduino: แนวคิดพื้นฐาน Arduino คืออะไร

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

Arduino คืออะไร

หากคุณเรียกจอบว่าจอบ Arduino ก็เป็นคอนสตรัคเตอร์สำหรับผู้ที่เบื่อการสร้างภาพที่ไร้ประโยชน์และต้องการให้ชีวิตน้อยๆ แก่พวกเขา ในกรณีที่ง่ายที่สุด Arduino - แผงวงจรพิมพ์ซึ่งมีตัวควบคุม, คริสตัลออสซิลเลเตอร์, ADC / DAC, ตัวเชื่อมต่อหลายตัว, ไดโอดและปุ่มต่างๆ ที่เหลือคืองานของเจ้าของ: ถ้าคุณต้องการ - สร้างหุ่นยนต์ ถ้าคุณต้องการ - แพลตฟอร์มฮาร์ดแวร์และซอฟต์แวร์สำหรับบ้าน "อัจฉริยะ" หรือลืมประโยชน์ที่ใช้งานได้จริงและสนุกไปกับมัน

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

Arduino ค่อนข้างจำกัดในแง่ของความเป็นไปได้ในการเขียนโปรแกรม โดยเฉพาะเมื่อเปรียบเทียบกับ Raspberry Pi เนื่องจากเกณฑ์การเข้าต่ำอย่างไม่เหมาะสม (บทช่วยสอนพื้นฐานใช้รูปแบบ A4 3 แผ่น) จึงไม่จำเป็นต้องพึ่งพาภาษามากมายโดยไม่ต้องเชื่อมต่อโมดูลเพิ่มเติม มันขึ้นอยู่กับ C/C++ แต่ด้วยความช่วยเหลือของ IDE และไลบรารีต่างๆ คุณจะสามารถเข้าถึง Python, C#, Go และความสนุกแบบเด็กๆ เช่น Snap! และ ArduBlock เราจะพูดถึงวิธีการใช้เมื่อใดและกับใคร

ซี/ซี++

ภาษาพื้นฐานของแพลตฟอร์ม Arduino ซึ่งมีการปรับเปลี่ยนและทำให้ง่ายขึ้นบางส่วนใช้ในเชลล์ซอฟต์แวร์มาตรฐาน คุณสามารถค้นหาคำสั่งที่มีอยู่ทั้งหมด "สำหรับผู้เริ่มต้น" แต่ไม่มีใครขัดขวางไม่ให้คุณใช้คุณสมบัติดั้งเดิมของภาษา C ++ ไม่จำเป็นต้องใช้ส่วนเสริม หากคุณต้องการเล่นกับ C "บริสุทธิ์" ที่บริการของคุณคือโปรแกรมที่ออกแบบมาตามชื่อที่สื่อถึงสำหรับการโต้ตอบกับ Windows และ AVR series MK ซึ่งใช้กับ Arduino มากกว่า คู่มือโดยละเอียดคุณสามารถอ่านได้ที่นี่

อาร์ดูบล็อก

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

อย่างไรก็ตาม หากต้องการใช้งาน คุณต้องติดตั้ง . เวอร์ชันล่าสุดเป็นการดีกว่าที่ไม่ควรพลาดมันค่อนข้างซับซ้อนเหมาะสำหรับการเริ่มต้นภายในสิ้นปี 2556 ในการติดตั้ง ให้เปลี่ยนชื่อไฟล์ที่ดาวน์โหลดเป็น “ardublock-all” และวางไว้ในโฟลเดอร์ “My Documents/Arduino/tools/ArduBlockTool/tool” ถ้าไม่มีเราสร้างมันขึ้นมา หากคุณไม่เข้าใจบางสิ่งนี่คือรายละเอียดเพิ่มเติม

งับ!

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

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

หลาม

คุณสามารถตั้งโปรแกรมบน Arduino ได้อย่างเป็นทางการโดยใช้ภาษา Piet เป็นอย่างน้อย เพราะด้วยความอุตสาหะ คุณจะคอมไพล์ทุกอย่างลงในรหัสเครื่องได้ แต่เนื่องจากความจริงที่ว่า Python เป็นหนึ่งในภาษาที่ได้รับความนิยมมากที่สุดด้วยการผสมผสานความซับซ้อน / ความสามารถที่เกือบจะเหมาะสมที่สุด การเลี่ยงการใช้งานใน Arduino จึงเป็นเรื่องไร้สาระ คุณสามารถเริ่มเรียนรู้ Python ด้วยไฟล์ .

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

ไปและภาษาอื่นๆ

เช่นเดียวกับที่ Arduino สื่อสารกับ Python ผ่านไลบรารี PySerial มันสามารถสื่อสารกับ Java, c Java, HTML และสิ่งที่คุณต้องการ Arduino เป็นแพลตฟอร์มที่ได้รับความนิยมมากพอที่คำถามซ้ำซากเช่นการเลือกภาษาที่สะดวกไม่ได้หยุดนักวิจัยคนอื่น สิ่งเดียวที่เจ้าของกระดานขนาดเล็กนี้ต้องการก็คือการคิดบางสิ่งที่น่าสนใจอย่างน่าอัศจรรย์ และเครื่องมือที่มีประโยชน์จะต้องถูกค้นพบอย่างหลีกเลี่ยงไม่ได้

คำสั่งภาษา การเขียนโปรแกรม Arduino

ภาษาการเขียนโปรแกรม Arduino ขึ้นอยู่กับภาษาซี หากคุณต้องการดูคำสั่งของภาษานี้ ให้รันคำสั่งเมนูในสภาพแวดล้อมการเขียนโปรแกรม วิธีใช้ / สารบัญ. คำสั่งถูกจัดกลุ่มเป็นสามคอลัมน์:

· โครงสร้าง: คำสั่งสำหรับเขียนโครงสร้างโปรแกรม - ลูป, แบรนช์, วากยสัมพันธ์, ตัวดำเนินการเลขคณิตและตรรกะ, ตัวดำเนินการเปรียบเทียบและการจัดการบิต

· ตัวแปร: ตัวแปรต่างๆ คล้ายกับที่ใช้ใน C มีเพียงไม่กี่ตัวเท่านั้นที่ใช้กับ Arduino:

โอ สูง- ระดับสูง, ลอจิก 1, +5 โวลต์บนพิน Arduino

โอ ต่ำ- ระดับต่ำ ลอจิก 0.0 โวลต์บนขา Arduino

โอ ป้อนข้อมูล- กำหนดผู้ติดต่อ Arduino เป็นอินพุต (รับข้อมูลจากอุปกรณ์ภายนอก)

โอ เอาต์พุต- การกำหนดผู้ติดต่อ Arduino เป็นเอาต์พุต (การถ่ายโอนข้อมูลไปยังอุปกรณ์ภายนอก, การควบคุมหน่วยพลังงาน)

· ฟังก์ชั่น: ฟังก์ชั่นที่ใช้ในการทำงานร่วมกับ Arduino จะกล่าวถึงโดยละเอียดในบทเรียนต่อไปนี้

หมายเหตุ 1: โครงสร้างและตัวแปรจะคล้ายกับที่ใช้ในโปรแกรมภาษาซี กล่าวคือ หากคุณทราบแล้ว ภาษาที่กำหนด- เชี่ยวชาญการเขียนโปรแกรม Arduino และในทางกลับกันได้อย่างง่ายดาย การเรียนรู้ภาษาโปรแกรม Arduino จะช่วยให้คุณเชี่ยวชาญภาษา C และอื่น ๆ

โน้ต 2: คำอธิบายของคำสั่งในคำแนะนำที่แนบมากับสภาพแวดล้อมจะได้รับบน ภาษาอังกฤษซึ่งอาจเป็นปัญหาได้ การแปลคำอธิบายเป็นภาษารัสเซียมีอยู่ในเว็บไซต์ Arduino.ru

หมายเหตุ 3: สามารถรับคำอธิบายของคำสั่งในโปรแกรมได้โดยเลือกคำสั่งนี้และดำเนินการ วิธีใช้ / ค้นหาในวิธีใช้.

ไวยากรณ์ภาษาการเขียนโปรแกรม Arduino

คล้ายกับที่ใช้ในภาษาซี:

· ; - เครื่องหมายอัฒภาค ระบุจุดสิ้นสุดของบรรทัด ตัวอย่างการใช้งาน:

int นำ = 13;

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

· { } - วงเล็บเหลี่ยม วงเล็บปีกกาเปิดคือจุดเริ่มต้นของบล็อก วงเล็บปีกกาปิดคือจุดสิ้นสุดของบล็อก

การตั้งค่าเป็นโมฆะ () {

pinMode (นำ, เอาต์พุต);

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

ล่าช้า (1,000); // รอหนึ่งวินาที (1,000 มิลลิวินาที)

· #รวม<назавние библиотеки.h> - การเชื่อมต่อห้องสมุด - ชุดของโปรแกรม เช่น เพื่อควบคุมไฟแสดงสถานะ LCD:

#รวม

บันทึก: เครื่องหมายอัฒภาคหลัง # ไม่จำเป็นต้องรวม

คำสั่งภาษาการเขียนโปรแกรม Arduino - แนวคิดและประเภท การจำแนกประเภทและคุณสมบัติของหมวดหมู่ "คำสั่งภาษาโปรแกรม Arduino" 2017, 2018

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

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

ถ้างบ

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

ถ้า(เงื่อนไข) ( statement1; statement2; )

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

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

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

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

ถ้า(init()) ( Serial.print("ตกลง"); )

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

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

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

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

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

ถ้า (init()) ( Serial.print("ok"); ) อื่น ( Serial.print("error"); )

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

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

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

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

ถ้า (!init()) ( Serial.print("ok"); ) อื่น ( Serial.print("error"); )

เปลี่ยนคำสั่งกรณี

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

สวิตช์ (var) ( กรณีที่ 1: // คำแนะนำสำหรับ var=1 break; กรณีที่ 2: // คำแนะนำสำหรับ var=2 break; default: // คำสั่งโดยค่าเริ่มต้น (หาก var แตกต่างจาก 1 และ 2) )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

intx=10; ทำ ( // บล็อกคำสั่ง x—; ) while(x>0); —————————————- do ( // บล็อกคำสั่ง if(condition) break; ) while(true);

คำสั่งทำลาย

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

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

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

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

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

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

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

ส่งคืนใบแจ้งยอด

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

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

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

ถือเป็นโมฆะ function_name() ( statement1; if(x==0) return; statement2; statement3; )

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

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

ไปที่คำสั่ง

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

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

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

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

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

โครงสร้างของโปรแกรม Arduino

โครงสร้างของโปรแกรม Arduino ค่อนข้างเรียบง่ายและในรูปแบบขั้นต่ำประกอบด้วยสองส่วน setup() และ loop()

การตั้งค่าเป็นโมฆะ () (

เป็นโมฆะวน () (

ฟังก์ชัน setup() จะทำงานเพียงครั้งเดียว เมื่อคอนโทรลเลอร์เปิดหรือรีเซ็ต มันมักจะเกิดขึ้น การตั้งค่าเริ่มต้นตัวแปร รีจิสเตอร์ ฟังก์ชันต้องมีอยู่ในโปรแกรมแม้ว่าจะไม่มีสิ่งใดอยู่ในนั้นก็ตาม

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

กฎไวยากรณ์ดั้งเดิมของภาษาซี

; อัฒภาคนิพจน์สามารถมีช่องว่างจำนวนมากโดยพลการ ขึ้นบรรทัดใหม่ สัญลักษณ์ของการสิ้นสุดนิพจน์คือสัญลักษณ์ "เซมิโคลอน"

z = x + y
z=x
+y;

( ) วงเล็บปีกกากำหนดฟังก์ชันหรือนิพจน์บล็อก ตัวอย่างเช่น ในฟังก์ชัน setup() และ loop()

/* … */ บล็อกความคิดเห็นอย่าลืมปิด

/* นี่คือบล็อกความคิดเห็น */

// ความคิดเห็นบรรทัดเดียว, ไม่ต้องปิด , ใช้ได้จนจบบรรทัด.

// นี่คือหนึ่งบรรทัดความคิดเห็น

ตัวแปรและชนิดข้อมูล

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

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

การประกาศตัวแปร

มีการระบุชนิดข้อมูลตามด้วยชื่อตัวแปร

intx; // การประกาศตัวแปรชื่อ x ชนิด int
float-widthBox; // ประกาศตัวแปรชื่อ widthBox ชนิด float

ต้องประกาศตัวแปรทั้งหมดก่อนใช้งาน

ตัวแปรสามารถประกาศในส่วนใดก็ได้ของโปรแกรม แต่ขึ้นอยู่กับบล็อกของโปรแกรมที่สามารถใช้ตัวแปรนั้น เหล่านั้น. ตัวแปรมีขอบเขต

• ตัวแปรที่ประกาศในตอนต้นของโปรแกรม ก่อนฟังก์ชัน void setup() จะถือเป็นตัวแปรส่วนกลางและมีอยู่ทุกที่ในโปรแกรม
• ตัวแปรโลคัลถูกประกาศภายในฟังก์ชันหรือบล็อก เช่น for loop และสามารถใช้ได้เฉพาะในบล็อกที่ประกาศเท่านั้น ตัวแปรหลายตัวที่มีชื่อเดียวกันแต่มีขอบเขตต่างกันได้

intmode; // ตัวแปรสามารถใช้ได้กับทุกฟังก์ชั่น

การตั้งค่าเป็นโมฆะ () (
// บล็อกว่าง ไม่ต้องตั้งค่าเริ่มต้น
}

เป็นโมฆะวน () (

นับยาว // ตัวแปรนับมีอยู่ในฟังก์ชัน loop() เท่านั้น

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

เมื่อประกาศตัวแปร คุณสามารถตั้งค่าเริ่มต้น (initialize)

int x = 0; // ตัวแปร x ถูกประกาศด้วยค่าเริ่มต้น 0
ถ่าน d = 'a'; // ตัวแปร d ถูกประกาศด้วยค่าเริ่มต้นเท่ากับรหัสอักขระ ”a”

ในระหว่างการดำเนินการทางคณิตศาสตร์กับประเภทข้อมูลที่แตกต่างกัน การแปลงประเภทข้อมูลอัตโนมัติจะเกิดขึ้น แต่จะดีกว่าถ้าใช้การแปลงที่ชัดเจนเสมอ

intx; // ตัวแปร int
ชารี; // ตัวแปรถ่าน
intz; // ตัวแปร int

z = x + (int) y; // ตัวแปร y ถูกแปลงเป็น int อย่างชัดเจน

การดำเนินการทางคณิตศาสตร์

การดำเนินงานสัมพันธ์

การดำเนินการเชิงตรรกะ

การดำเนินการกับพอยน์เตอร์

การทำงานของบิต

การดำเนินการมอบหมายแบบผสม

ทางเลือกของตัวเลือกการจัดการโปรแกรม

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

ถ้า (x == 5) // ถ้า x=5 ดังนั้น z=0 จะถูกดำเนินการ
z=0;

ถ้า (x > 5) // ถ้า x >
( z=0; y=8; )

ถ้า…อื่น ๆให้คุณเลือกระหว่างสองตัวเลือก

ถ้า (x > 5) // ถ้า x > 5 บล็อก z=0, y=8 จะถูกดำเนินการ;
{
z=0;
ย=8;
}

{
z=0;
y=0;
}

อื่น ๆ ถ้า- ให้คุณเลือกได้หลายแบบ

ถ้า (x > 5) // ถ้า x > 5 บล็อก z=0, y=8 จะถูกดำเนินการ;
{
z=0;
ย=8;
}

อื่นถ้า (x > 20) // ถ้า x > 20 ดำเนินการบล็อกนี้
{
}

อื่น // มิฉะนั้นบล็อกนี้จะถูกดำเนินการ
{
z=0;
y=0;
}

กรณีสวิตช์- ปรนัย. ให้คุณเปรียบเทียบตัวแปร (ในตัวอย่างคือ x) กับค่าคงที่หลายค่า (ในตัวอย่างที่ 5 และ 10) และดำเนินการบล็อกที่ตัวแปรมีค่าเท่ากับค่าคงที่

สวิตช์ (x) (

กรณีที่ 5:
// รหัสถูกดำเนินการถ้า x = 5
หยุดพัก;

กรณีที่ 10:
// รหัสถูกดำเนินการถ้า x = 10
หยุดพัก;

ค่าเริ่มต้น:
// รหัสจะถูกดำเนินการหากไม่มีค่าก่อนหน้าที่ตรงกัน
หยุดพัก;
}

สำหรับลูป. โครงสร้างช่วยให้คุณสามารถจัดระเบียบรอบด้วยจำนวนการวนซ้ำที่กำหนด ไวยากรณ์มีลักษณะดังนี้:

สำหรับ (การกระทำก่อนเริ่มลูป;
เงื่อนไขสำหรับการดำเนินการต่อวงจร
การดำเนินการเมื่อสิ้นสุดการวนซ้ำแต่ละครั้ง) (

// วนรหัสเนื้อหา

ตัวอย่างของการวนซ้ำ 100 ครั้ง

สำหรับ (i=0; i< 100; i++) // начальное значение 0, конечное 99, шаг 1

{
ผลรวม = ผลรวม + ฉัน;
}

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

ในขณะที่ (นิพจน์)
{
// วนรหัสเนื้อหา
}

การวนซ้ำจะดำเนินการตราบเท่าที่นิพจน์ในวงเล็บเป็นจริง ตัวอย่างการวนซ้ำ 10 รอบ

x = 0;
ในขณะที่ (x< 10)
{
// วนรหัสเนื้อหา
x++;
}

ทำในขณะที่เป็นลูปที่มีเงื่อนไขที่ทางออก

ทำ
{
// วนรหัสเนื้อหา
) ในขณะที่ (นิพจน์);

การวนซ้ำจะดำเนินการในขณะที่นิพจน์เป็นจริง
หยุดพัก- ตัวดำเนินการออกจากวง ใช้เพื่อขัดจังหวะการดำเนินการ สำหรับลูป, ในขณะที่, ทำในขณะที่.

x = 0;
ในขณะที่ (x< 10)
{
ถ้า (z > 20) แตก; // ถ้า z > 20 ให้ออกจากลูป
// วนรหัสเนื้อหา
x++;
}

ไปที่เป็นตัวดำเนินการกระโดดแบบไม่มีเงื่อนไข

ไปที่ป้ายกำกับ 1; // เปลี่ยนเป็น metka1
………………
metka1:

ดำเนินการต่อ- ข้ามคำสั่งไปที่ส่วนท้ายของลูป

x = 0;
ในขณะที่ (x< 10)
{
// วนรหัสเนื้อหา
ถ้า (z > 20) ดำเนินการต่อ; // ถ้า z > 20 ให้กลับไปที่จุดเริ่มต้นของตัวลูป
// วนรหัสเนื้อหา
x++;
}

อาร์เรย์

อาร์เรย์เป็นพื้นที่ของหน่วยความจำที่เก็บตัวแปรหลายตัวตามลำดับ

มีการประกาศอาร์เรย์แบบนี้

อายุ int; // อาร์เรย์ของตัวแปร int 10 ตัว

ลอยน้ำ; // อาร์เรย์ของตัวแปรโฟลต 100 ตัว

เมื่อประกาศ อาร์เรย์สามารถเริ่มต้นได้:

int อายุ = ( 23, 54, 34, 24, 45, 56, 23, 23, 27, 28);

มีการเข้าถึงตัวแปร Array ดังนี้:

x = อายุ; // x เป็นการกำหนดค่าขององค์ประกอบ 5 ของอาร์เรย์
อายุ=32; // องค์ประกอบอาร์เรย์ 9 ถูกกำหนดเป็น 32

องค์ประกอบอาร์เรย์จะมีหมายเลขจากศูนย์เสมอ

ฟังก์ชั่น.

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

• ชื่อที่เธอเรียก;
• อาร์กิวเมนต์ - ข้อมูลที่ฟังก์ชันใช้ในการคำนวณ
• ชนิดข้อมูลที่ส่งคืนโดยฟังก์ชัน

อธิบายฟังก์ชันที่ผู้ใช้กำหนดนอกฟังก์ชัน setup() และ loop()

การตั้งค่าเป็นโมฆะ () (
// รหัสถูกเรียกใช้ครั้งเดียวเมื่อโปรแกรมเริ่มทำงาน
}

เป็นโมฆะวน () (
// รหัสหลักทำงานในลูป
}

// การประกาศของฟังก์ชั่นที่กำหนดเองชื่อ functionName
พิมพ์ functionName(พิมพ์อาร์กิวเมนต์ 1, พิมพ์อาร์กิวเมนต์ 1, … , พิมพ์อาร์กิวเมนต์)
{
// ร่างกายของฟังก์ชั่น
กลับ();
}

ตัวอย่างของฟังก์ชันที่คำนวณผลรวมของกำลังสองของอาร์กิวเมนต์สองตัว

int sumQwadr (int x, int y)
{
กลับ (x* x + y*y);
}

การเรียกใช้ฟังก์ชันจะเป็นดังนี้:

ง=2; ข=3;
z= ผลรวม Qwadr(d, b); // z จะเป็นผลรวมของกำลังสองของตัวแปร d และ b

ฟังก์ชั่นสามารถสร้างขึ้นเอง, กำหนดเอง, ปลั๊กอิน

สั้นมาก แต่ข้อมูลนี้น่าจะเพียงพอที่จะเริ่มเขียนโปรแกรม C สำหรับระบบ Arduino

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

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

ชื่อในภาษาซี

ชื่อที่แสดงถึงประเภทข้อมูลจะต้องเขียนเป็นตัวพิมพ์ผสมกัน ตัวอักษรตัวแรกของชื่อจะต้องเป็นตัวพิมพ์ใหญ่ (ตัวพิมพ์ใหญ่)

สัญญาณ, TimeCount

ตัวแปรต้องเขียนด้วยชื่อตัวพิมพ์ผสมกัน ตัวอักษรตัวแรกเป็นตัวพิมพ์เล็ก (ตัวพิมพ์เล็ก)

ในอดีต ส่วนซอฟต์แวร์ Arduino ประกอบด้วยส่วนรวม สภาพแวดล้อมซอฟต์แวร์(IDE) ซึ่งอนุญาตให้คุณเขียน คอมไพล์ และอัพโหลดโค้ดที่เขียนไปยังฮาร์ดแวร์ สภาพแวดล้อม ArduinoIDE และภาษา Wiring นั้นขึ้นอยู่กับการประมวลผลเป็นหลักโดยอ้อมบน C / C ++ ในความเป็นจริง Arduino IDE เป็นการผสมผสานขนาดใหญ่ไม่ใช่เพื่อความสนุก แต่เพื่อความสะดวก

แม้ภายนอกและอาดูรโน่ไอดีและการประมวลผลจะคล้ายกัน

ฮาร์ดแวร์ «สวัสดี, โลก!" - ไฟ LED กะพริบ
สิ่งที่เริ่มต้นความคุ้นเคยครั้งแรกกับ Arduino ที่ทางแยกของซอฟต์แวร์และฮาร์ดแวร์คือการกระพริบของ LED

ก่อนอื่นคุณต้องกรอกโปรแกรมขั้นต่ำให้เสร็จ สำหรับ Arduino (เช่น UNO) เราเชื่อมต่อ LED กับพิน 12 และ GND (สีของ LED นั้นถูกเลือกจากความชอบส่วนบุคคล)

การตั้งค่าเป็นโมฆะ () ( pinMode (12, OUTPUT); ) โมฆะลูป () ( digitalWrite (12, สูง); ล่าช้า (100); digitalWrite (12, ต่ำ); ล่าช้า (900); )
ทำ Ctrl+C -> Ctrl+V, คอมไพล์, โหลด, กฎ เราเห็นการแสดงแสงที่กินเวลาไม่เกินหนึ่งวินาที ลองหาสาเหตุที่สิ่งนี้เกิดขึ้น

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

เกิดอะไรขึ้นระหว่าง{ } ?
อย่างที่คุณทราบ พิน Arduino สามารถทำงานได้ทั้งอินพุตและเอาต์พุต เมื่อเราต้องการควบคุมบางอย่าง เราจำเป็นต้องถ่ายโอนขาควบคุมไปยังสถานะเอาต์พุต สิ่งนี้ทำได้โดยนิพจน์ในฟังก์ชันติดตั้ง :
โหมดพิน (12, เอาต์พุต); ในสถานการณ์นี้การแสดงออก การเรียกใช้ฟังก์ชัน . ใน pinMode พินที่ระบุด้วยตัวเลขจะถูกตั้งค่าเป็นโหมดที่ระบุ (INPUT หรือ OUTPUT) พินใดและโหมดใดที่เป็นปัญหาจะระบุไว้ในวงเล็บ คั่นด้วยเครื่องหมายจุลภาค ในกรณีของเรา เราต้องการให้พินที่ 12 ทำงานเป็นเอาต์พุต OUTPUT หมายถึง เอาต์พุต INPUT หมายถึง อินพุต ค่าที่กำหนดเช่น 12 และ OUTPUT ถูกเรียก อาร์กิวเมนต์ของฟังก์ชัน . จำนวนอาร์กิวเมนต์ของฟังก์ชันขึ้นอยู่กับสาระสำคัญของฟังก์ชันและเจตจำนงของผู้สร้าง ฟังก์ชันสามารถไม่มีอาร์กิวเมนต์เลย เช่นเดียวกับการตั้งค่าและการวนซ้ำ

จากนั้นไปที่บล็อกวนตามลำดับ:
- เรียกใช้ฟังก์ชัน digitalWrite ในตัว ได้รับการออกแบบมาเพื่อจ่ายค่าศูนย์แบบลอจิคัล (ต่ำ, 0 โวลต์) หรือค่าแบบลอจิคัล (สูง, 5 โวลต์) ให้กับพินที่กำหนด 2 อาร์กิวเมนต์จะถูกส่งผ่านไปยังฟังก์ชัน digitalWrite: หมายเลขพินและค่าตรรกะ
- เรียกใช้ฟังก์ชันหน่วงเวลา นี่เป็นฟังก์ชันในตัวที่ทำให้โปรเซสเซอร์ "สลีป" อีกครั้ง เวลาที่แน่นอน. ใช้เวลาเพียงหนึ่งอาร์กิวเมนต์: เวลาในหน่วยมิลลิวินาทีเพื่อเข้าสู่โหมดสลีป ในกรณีของเรา นี่คือ 100 มิลลิวินาที ทันทีที่หมดเวลา 100 มิลลิวินาที โปรเซสเซอร์จะตื่นและไปยังนิพจน์ถัดไปทันที
- เรียกใช้ฟังก์ชันในตัว digitalWrite เฉพาะเวลานี้ อาร์กิวเมนต์ที่สองมีค่าต่ำ นั่นคือเราตั้งค่าศูนย์ตรรกะที่พินที่ 12 -> เราใช้ 0 โวลต์ -> ปิด LED
- เรียกใช้ฟังก์ชันหน่วงเวลา คราวนี้เรา "หลับ" นานขึ้นเล็กน้อย - 900 มิลลิวินาที

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

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

ด้วยความช่วยเหลือของพื้นที่ว่าง คุณสามารถทำให้โปรแกรมเข้าใจและมองเห็นได้ หรือในทางกลับกัน ทำลายมันจนจำไม่ได้ ตัวอย่างโปรแกรมที่ยกตัวอย่างสามารถแก้ไขได้ดังนี้
การตั้งค่าเป็นโมฆะ () ( pinMode (12, OUTPUT); ) โมฆะลูป () ( digitalWrite (12,สูง); ล่าช้า (100) ; digitalWrite (12, ต่ำ); ล่าช้า (900); )

เพื่อป้องกันไม่ให้ผู้อื่นเลือดไหลออกจากตาขณะอ่าน คุณสามารถปฏิบัติตามกฎง่ายๆ สองสามข้อ:

1. เสมอเมื่อเริ่มต้นบล็อกใหม่ระหว่าง( และ ) เพิ่มการเยื้อง โดยปกติจะใช้ 2 หรือ 4 ช่องว่าง เลือกหนึ่งในค่าและยึดติดกับมันตลอด

โมฆะวนรอบ () ( digitalWrite (12, สูง); ล่าช้า (100); digitalWrite (12, ต่ำ); ล่าช้า (900); )
2. เช่นเดียวกับภาษาปกติ ให้เว้นวรรคหลังเครื่องหมายจุลภาค

digitalWrite (12, สูง);
3. วางอักขระเริ่มต้นของบล็อก ( บน บรรทัดใหม่ที่ระดับการเยื้องปัจจุบันหรือที่ส่วนท้ายของการเยื้องก่อนหน้า และอักขระท้ายบล็อก ) ในบรรทัดแยกที่ระดับการเยื้องปัจจุบัน:

การตั้งค่าเป็นโมฆะ () ( pinMode (12, OUTPUT); ) การตั้งค่าเป็นโมฆะ () ( pinMode (12, OUTPUT); )
4. ใช้บรรทัดว่างเพื่อแยกบล็อกความหมาย:

void loop() ( digitalWrite(12, สูง); หน่วงเวลา(100); digitalWrite(12, ต่ำ); หน่วงเวลา(900); digitalWrite(12, สูง); หน่วงเวลา(100); digitalWrite(12, ต่ำ); หน่วงเวลา( 900); )
5. เพื่อให้ผลิตผลของคุณน่าอ่านมีความคิดเห็นที่เรียกว่า สิ่งเหล่านี้คือโครงสร้างในโค้ดโปรแกรมที่คอมไพเลอร์ละเว้นโดยสิ้นเชิงและมีความสำคัญต่อบุคคลที่อ่านเท่านั้น ความคิดเห็นสามารถเป็นหลายบรรทัดหรือบรรทัดเดียว:

/* นี่คือความคิดเห็นหลายบรรทัด */ // นี่คือบรรทัดเดียว