Arduino และภาษาการเขียนโปรแกรมที่รองรับ ภาษาการเขียนโปรแกรม Arduino การเขียนโปรแกรม Arduino Arduino

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

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

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

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

การตั้งค่าเป็นโมฆะ () ( pinMode (12, OUTPUT); ) void loop () ( 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 ms ทันทีที่ 100 ms หมดลง โปรเซสเซอร์จะเริ่มทำงานและไปยังนิพจน์ถัดไปทันที
- เรียกใช้ฟังก์ชัน digitalWrite ในตัว เฉพาะครั้งนี้เท่านั้นที่อาร์กิวเมนต์ที่สองคือ LOW นั่นคือเราตั้งค่าศูนย์ลอจิคัลบนพินที่ 12 -> ใช้ 0 โวลต์ -> ปิด LED
- การเรียกใช้ฟังก์ชันการหน่วงเวลา ครั้งนี้เรา “นอนหลับ” นานขึ้นอีกหน่อย – 900 มิลลิวินาที

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

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

ด้วยความช่วยเหลือของพื้นที่ว่างคุณสามารถสร้างโปรแกรมที่เข้าใจง่ายและมองเห็นได้หรือในทางกลับกันทำให้เสียโฉมเกินกว่าจะจดจำได้ ตัวอย่างเช่น โปรแกรมตัวอย่างสามารถเปลี่ยนแปลงได้ดังนี้:
การตั้งค่าเป็นโมฆะ () ( pinMode (12, OUTPUT); ) void loop () ( 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. เพื่อให้ลูกของคุณสนุกกับการอ่านมีสิ่งที่เรียกว่าความคิดเห็น สิ่งเหล่านี้คือโครงสร้างในโค้ดโปรแกรมที่คอมไพเลอร์ละเลยโดยสิ้นเชิงและมีความสำคัญต่อผู้ที่อ่านเท่านั้น ความคิดเห็นอาจเป็นหลายบรรทัดหรือบรรทัดเดียว:

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

หลังจากทำความคุ้นเคยกับองค์ประกอบพื้นฐานของ Arduino พร้อมเขียนโปรแกรม “Hello World!” แล้ว ถึงเวลาทำความคุ้นเคยกับภาษาการเขียนโปรแกรมแล้ว

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

ข้อมูลส่วนใหญ่ในที่นี้จะเข้ากันได้กับหลักสูตร C/C++ ใดๆ โดยคำนึงถึงความแตกต่างในประเภทข้อมูล ตลอดจนคำแนะนำเฉพาะบางประการเกี่ยวกับการเขียนโปรแกรมพอร์ต I/O

พื้นฐาน

สิ่งที่เป็นทางการบางอย่าง นั่นคือ สิ่งที่ทุกคนรู้จัก แต่บางครั้งก็ลืม...

ใน Arduino IDE เช่นเดียวกับใน C/C++ คุณต้องระวังตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ คำสำคัญเช่น if, for จะถูกเขียนด้วยตัวพิมพ์เล็กเสมอ แต่ละคำสั่งจะลงท้ายด้วย ";" อัฒภาคจะบอกคอมไพเลอร์ว่าส่วนใดที่จะตีความว่าเป็นคำสั่ง

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

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

หากเราต้องการรวมไลบรารีใดๆ ไว้ในโปรแกรมของเรา เราจะใช้คำสั่ง include นี่คือตัวอย่างของการเชื่อมต่อไลบรารี:

#รวม // ไลบรารีมาตรฐาน #include “svoya_biblioteka.h” // ไลบรารีในไดเร็กทอรีโครงการ

ฟังก์ชั่นต่างๆ ใน ​​Arduino

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

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

การประกาศฟังก์ชั่น

แผนภาพการประกาศฟังก์ชันมีลักษณะดังนี้:

พิมพ์ function_name(parameter) ( // คำแนะนำสำหรับการดำเนินการ (เนื้อหาของฟังก์ชัน) return (/* return value*/); )

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

หลังจากดำเนินการแล้ว ฟังก์ชันจะส่งกลับค่าของประเภทที่ประกาศไว้ หากฟังก์ชันไม่ยอมรับค่าที่ส่งคืน ชนิดข้อมูลจะเป็น "โมฆะ"

function_nameช่วยให้สามารถระบุได้โดยไม่ซ้ำกัน เพื่อที่จะเรียกใช้ (รัน) ฟังก์ชัน เราจะตั้งชื่อให้กับมัน

พารามิเตอร์- พารามิเตอร์การเรียกใช้ฟังก์ชัน พารามิเตอร์ไม่จำเป็น แต่มักจะมีประโยชน์ หากเราเขียนฟังก์ชันที่ไม่มีอาร์กิวเมนต์ เราจะปล่อยวงเล็บว่างไว้

ภายในวงเล็บ “(…)” คือส่วนที่แท้จริงของฟังก์ชันหรือคำสั่งที่เราต้องการดำเนินการ เราจะให้คำอธิบายคำแนะนำเฉพาะในบทความแยกต่างหาก

ฟังก์ชันทั้งหมดที่ส่งคืนค่าที่ลงท้ายด้วยคำสั่ง return ตามด้วยค่าที่ส่งคืน เฉพาะฟังก์ชันที่ประกาศด้วยตัวชี้ null ("โมฆะ") เท่านั้นที่ไม่มีคำสั่ง return คุณจำเป็นต้องรู้ว่าคำสั่ง return ยุติฟังก์ชันโดยไม่คำนึงถึงตำแหน่ง

ด้านล่างนี้เป็นตัวอย่างบางส่วนของการประกาศฟังก์ชัน

เป็นโมฆะ f1() ( //function body) —————————————— int ลบ() ( //function body return (0); ) ——————————— ——— int บวก(int a, int b) ( กลับ (a+b); )

ดังที่คุณเห็นจากตัวอย่าง การประกาศฟังก์ชันอาจมีหลายรูปแบบขึ้นอยู่กับความต้องการของคุณ

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

ตอนนี้เรารู้วิธีเขียนฟังก์ชันของเราเองแล้ว เราต้องเรียนรู้วิธีใช้งานมันด้วย

การเรียกใช้ฟังก์ชัน

เราเขียนฟังก์ชันทั้งหมดไว้ในไฟล์/โปรแกรมเดียว แน่นอนว่ายังมีวิธีแก้ปัญหาที่หรูหรากว่านี้ แต่เราจะพยายามอธิบายในครั้งต่อไป

เมื่อเราประกาศฟังก์ชันแล้ว เราก็สามารถใช้ฟังก์ชันนั้นในฟังก์ชันอื่นด้วยชื่อที่เหมาะสมและพารามิเตอร์ที่จำเป็นได้ ด้านล่างนี้เป็นตัวอย่างของการเรียกใช้ฟังก์ชันที่เราให้ไว้ข้างต้น:

F1(); บวก(2,2); y=บวก(1.5);

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

หากมีการประกาศฟังก์ชัน f1() โดยไม่มีพารามิเตอร์ จะไม่สามารถระบุพารามิเตอร์ได้เมื่อเรียกใช้ฟังก์ชันดังกล่าว กล่าวคือ การเรียก f1(0) จะไม่ถูกต้อง

ฟังก์ชัน plus(int a, int b) ต้องการพารามิเตอร์สองตัวพอดี ดังนั้นจึงไม่สามารถเรียกด้วยพารามิเตอร์หนึ่งหรือสามตัวได้

การเรียก y=plus(1,5) จะดำเนินการฟังก์ชัน "plus" ด้วยพารามิเตอร์ "1" และ "5" และเก็บค่าที่ส่งคืนไว้ในตัวแปร "y"

ฟังก์ชั่น setup() และ loop()

ด้วยความรู้เกี่ยวกับการประกาศฟังก์ชันและการเรียกใช้ เราสามารถไปยังฟังก์ชันของระบบ Arduino ได้: ติดตั้ง()และ วนซ้ำ(). Arduino IDE จำเป็นต้องประกาศฟังก์ชันทั้งสองนี้

setup() เป็นฟังก์ชันที่ถูกเรียกโดยอัตโนมัติเมื่อเปิดเครื่องหรือกดปุ่ม RESET

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

การตั้งค่าเป็นโมฆะ () ( // เนื้อความของฟังก์ชัน - การเริ่มต้นระบบ)

loop() เป็นฟังก์ชันที่ถูกเรียกในวงวนไม่สิ้นสุด ฟังก์ชั่นนี้ยังไม่ส่งคืนค่าและไม่ถูกเรียกด้วยพารามิเตอร์ การประกาศฟังก์ชัน loop() ที่ถูกต้องแสดงอยู่ด้านล่าง:

Void loop () ( // เนื้อความของฟังก์ชัน - รหัสโปรแกรม)

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

ตอนนี้เราจะวิเคราะห์รหัสเทียมต่อไปนี้:

การตั้งค่าเป็นโมฆะ () ( on_led1 (); // เปิด led1 off_led1 (); // ปิด led1) void loop () ( on_led2 (); // เปิด led2 off_led2 (); // ปิด led2)

มีสองคำสั่งในฟังก์ชันการตั้งค่า (): คำสั่งแรกจะเปิด led1 ที่เชื่อมต่อกับบอร์ด (เช่น พิน 13) และคำสั่งที่สองจะปิด led1

ฟังก์ชัน loop() มีคำสั่งเหมือนกันในการเปิดและปิด LED2 ที่เชื่อมต่อกับบอร์ด (เช่น พิน 12)

จากการรันโปรแกรม led1 จะกระพริบหนึ่งครั้ง ในขณะที่ led2 จะสว่างขึ้นและดับลงตราบใดที่ Arduino เปิดอยู่

การกดปุ่ม RESET จะทำให้ led1 กะพริบอีกครั้ง และ led2 กะพริบต่อเนื่องอีกครั้ง

สรุป:

• ฟังก์ชั่น setup() และ loop() คือ ฟังก์ชั่นระบบซึ่งจะต้องกำหนดไว้ในแต่ละโครงการ แม้ว่าในสถานการณ์ที่เราไม่ได้เขียนโค้ดใดๆ ในหนึ่งในนั้น เรายังคงต้องประกาศฟังก์ชันทั้งสองนี้
• ฟังก์ชัน setup() จะดำเนินการเพียงครั้งเดียว, loop() จะดำเนินการอย่างต่อเนื่อง;
• เราสร้างฟังก์ชันของเราเองในไฟล์เดียว
• เราสามารถเรียกใช้ฟังก์ชันของเราได้ทั้งจาก setup() และ loop() และจากฟังก์ชันอื่นๆ
• ฟังก์ชั่นของเราเองสามารถเรียกใช้ด้วยพารามิเตอร์และส่งกลับค่า
• การเรียกใช้ฟังก์ชันจะต้องดำเนินการตามการประกาศ

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

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

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

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

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

โอ ต่ำ– ระดับต่ำ, โลจิคัล 0.0 โวลต์บนพิน Arduino

โอ ป้อนข้อมูล– การลงทะเบียนผู้ติดต่อ Arduino เป็นอินพุต (รับข้อมูลจากอุปกรณ์ภายนอก)

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

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

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

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

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

ไวยากรณ์ภาษาโปรแกรม Arduino

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

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

int นำ = 13;

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

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

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

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

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

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

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

#รวม

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

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

ภาษาการเขียนโปรแกรม Arduino มีพื้นฐานมาจากภาษา C/C++ ซึ่งใช้กันอย่างแพร่หลายในโลกการเขียนโปรแกรม

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

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

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

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

อัฒภาค;

อัฒภาคจะต้องตามทุกนิพจน์ที่เขียนด้วยภาษาการเขียนโปรแกรม Arduino ตัวอย่างเช่น:

Int LEDพิน = 9;

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

แบ็กสแลชคู่สำหรับความคิดเห็นบรรทัดเดียว //

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

// เชื่อมต่อ LED เข้ากับขา Arduino นี้ int LEDpin = 9;

ตอนนี้ แม้จะผ่านไป 3 เดือนเมื่อฉันดูโปรแกรมนี้ ฉันก็รู้ว่า LED เชื่อมต่ออยู่ที่ไหน

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

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

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

วงเล็บปีกกา ( )

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

Void loop() ( //วงเล็บปีกกานี้เปิด //โปรแกรมเจ๋งๆ ที่นี่ ) //วงเล็บปีกกานี้ปิด

ข้อควรจำ - ไม่สามารถปล่อยเครื่องหมายปีกกาทิ้งไว้ได้!

ฟังก์ชั่น ()

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

1. รับถัง
2. เติมน้ำ
3. เพิ่มสบู่
4. หาสุนัข
5. ให้ฟองสุนัข
6. ล้างสุนัข
7. ล้างสุนัข
8. ทำให้สุนัขแห้ง
9. วางถังไว้ข้างๆ

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

Arduino มีฟังก์ชันบางอย่างที่มักใช้ใน . เมื่อคุณป้อนชื่อฟังก์ชันจะเป็นสีส้ม ตัวอย่างเช่น ฟังก์ชัน pinMode() เป็นฟังก์ชันทั่วไปที่ใช้ระบุโหมดพิน Arduino

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

พินโหมด(13, เอาต์พุต); //ตั้งค่าโหมดเอาท์พุต Arduino

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

มิลลิวินาที(); //รับเวลาเป็นมิลลิวินาทีที่ Arduino เริ่มทำงาน

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

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

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

การตั้งค่าเป็นโมฆะ() ( //โค้ดระหว่างเครื่องหมายปีกกาจะดำเนินการเพียงครั้งเดียว)

คุณอาจสงสัยว่า void หมายถึงอะไรก่อนฟังก์ชัน setup() เป็นโมฆะหมายความว่าฟังก์ชันไม่ส่งคืนข้อมูล

บางฟังก์ชั่นคืนค่า - ฟังก์ชั่น DogWash ของเราสามารถคืนจำนวนถังที่จำเป็นในการทำความสะอาดสุนัขได้ ฟังก์ชัน analogRead() ส่งกลับค่าจำนวนเต็มระหว่าง 0 ถึง 1,023 หากสิ่งนี้ดูแปลกไปเล็กน้อยในตอนนี้ ไม่ต้องกังวล เพราะเราจะครอบคลุมทุกอย่าง ฟังก์ชั่นทั่วไป Arduino ในขณะที่หลักสูตรดำเนินต่อไป

มาดูสองสิ่งที่คุณควรรู้เกี่ยวกับ setup():

1. setup() ทำงานเพียงครั้งเดียว;
2. setup() ควรเป็นฟังก์ชันแรกในร่าง Arduino
3. setup() ต้องมีเครื่องหมายปีกกาเปิดและปิด

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

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

เช่นเดียวกับ setup() loop() จะไม่ส่งคืนค่าใดๆ ดังนั้นจึงมีคำว่า void นำหน้า

Void loop() ( // รหัสใด ๆ ที่คุณระบุที่นี่จะถูกดำเนินการซ้ำแล้วซ้ำเล่า)

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

มีโปรแกรมอื่นที่ทำงานร่วมกับ Arduino หรือไม่?

นอกจาก Arduino IDE อย่างเป็นทางการแล้ว ยังมีโปรแกรมต่างๆ อีกด้วย นักพัฒนาบุคคลที่สามซึ่งนำเสนอผลิตภัณฑ์สำหรับการทำงานร่วมกับไมโครคอนโทรลเลอร์ที่ใช้ Arduino

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

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

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

คู่แข่งของ Arduino

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

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

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

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

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

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

ดาวน์โหลดหนังสือบน Arduino ในภาษารัสเซีย

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

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

โปรเจ็กต์ที่ใช้คอนโทรลเลอร์ Arduino เพติน วี.เอ.

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

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

Arduino และ Raspberry Pi ในโครงการ Internet of Things วิกเตอร์ เพติน

คำอธิบาย: ถือเป็นการสร้างอุปกรณ์ง่าย ๆ ภายในกรอบแนวคิดของ Internet of Things (IoT, Internet of Things) บนแพลตฟอร์ม Arduino ยอดนิยมและไมโครคอมพิวเตอร์ Raspberry Pi การติดตั้งและการกำหนดค่าสภาพแวดล้อมการพัฒนาจะแสดงขึ้น แอพพลิเคชั่น Arduino IDE รวมถึงสภาพแวดล้อมเค้าโครง Frizing มีการอธิบายความสามารถทางเทคนิค การเชื่อมต่อและการโต้ตอบ เซ็นเซอร์ต่างๆและแอคชูเอเตอร์ องค์กรของการเข้าถึงโครงการที่พัฒนาแล้วบนอินเทอร์เน็ต การส่งและรับข้อมูลโดยใช้บริการ Cloud IoT ยอดนิยมแสดงอยู่: Narodmon, ThingSpeak, Xively, Weaved, Blynk, Wyliodrin ฯลฯ ความสนใจจะจ่ายให้กับการแลกเปลี่ยนข้อมูลโดยใช้การ์ด GPRS/GSM Shield . โครงการสร้างเซิร์ฟเวอร์ของคุณเองเพื่อรวบรวมข้อมูลผ่านเครือข่าย อุปกรณ์ต่างๆบนแพลตฟอร์ม Arduino แสดงวิธีใช้เฟรมเวิร์ก WebIOPi เพื่อทำงานกับ Raspberry Pi มีตัวอย่างการใช้โมดูล ESP8266 Wi-Fi ในโครงการ สมาร์ทเฮ้าส์" เว็บไซต์ของผู้จัดพิมพ์ประกอบด้วยไฟล์เก็บถาวรพร้อมซอร์สโค้ดสำหรับโปรแกรมและไลบรารี
— การติดตั้งและการกำหนดค่าสภาพแวดล้อมการพัฒนาแอปพลิเคชัน Arduino IDE และสภาพแวดล้อมการสร้างต้นแบบ Frizing
— เซ็นเซอร์และแอคชูเอเตอร์สำหรับ Arduino และ Raspberry Pi
— การส่งและรับข้อมูลจากบริการ IoT Narodmon, ThingSpeak, Xively, Weaved, Blynk, Wyliodrin
— การสร้างเว็บเซิร์ฟเวอร์เพื่อรวบรวมข้อมูลจากอุปกรณ์ Android
— การแลกเปลี่ยนข้อมูลโดยใช้การ์ด GPRS/GSM Shield
— เฟรมเวิร์ก WebIOPi สำหรับการทำงานกับ Raspberry Pi
— โมดูล WiFi ESP8266 ในโครงการ "บ้านอัจฉริยะ"

เริ่มต้นอย่างรวดเร็ว ขั้นตอนแรกสู่การเรียนรู้ Arduino

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