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

บทนำ

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

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

“3 วิธีรับกระแสตรง ”

ในบทช่วยสอนนี้เราจะทำงานร่วมกับบอร์ด Arduino Uno เพื่อเรียนรู้และทดสอบโปรแกรม สำหรับการทดสอบและรวมการประกอบฮาร์ดแวร์เราจะใช้เขียงหั่นขนม

ตอนนี้มาดูกันอย่างรวดเร็วและเรียนรู้วิธีเริ่มต้นกับการเขียนโปรแกรม Arduino

1.2 การติดตั้งซอฟต์แวร์ (Windows)

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

ไฟล์ ZIP ของ Windows สำหรับการติดตั้งที่ไม่ใช่ผู้ดูแลระบบ

หลังจากดาวน์โหลดคุณจะพบไอคอนการตั้งค่า Arduino ในโฟลเดอร์ดาวน์โหลดซึ่งจะมีลักษณะดังนี้:

เมื่อคุณได้รับสิ่งนี้คุณสามารถดับเบิลคลิกและติดตั้ง Arduino the Integrated Development Environment (IDE) ในคอมพิวเตอร์ของคุณ กระบวนการทั้งหมดสามารถมองเห็นได้ในวิดีโอต่อไปนี้:

https://youtu.be/x7AMn1paCeU

1.4 เริ่มต้นด้วยวงจรแรกของเรา

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

อย่างที่เราทราบกันดีว่า LED คือไดโอดเปล่งแสงซึ่งมีขั้วและจะไม่ส่องสว่างหากไม่ได้เชื่อมต่อกับขั้วจ่ายที่ถูกต้อง

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

ตามกฎทั่วไป 330 โอห์ม 1/4 วัตต์เหมาะอย่างยิ่งสำหรับการเพิ่มขึ้นทุกๆ 5V ของอินพุตแหล่งจ่ายเพื่อ จำกัด กระแสให้อยู่ในระดับที่ปลอดภัยที่กำหนด ดังนั้นสำหรับ 5V อาจเป็น 330 โอห์มสำหรับ 10V อาจเป็น 680 โอห์มเป็นต้น

การใช้ Breadboard สำหรับการประกอบ

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

การตั้งค่าการเชื่อมต่อ LED พื้นฐานสามารถดูได้ด้านล่าง:

คุณสามารถดูส่วนประกอบพื้นฐาน 3 อย่างด้านบน:

LED ขนาด 5 มม., 20mA
ตัวต้านทาน 330 โอห์ม 1/4 วัตต์
อัน บอร์ด Arduino

เพียงแค่ประกอบระบบตามแผนภาพ

จากนั้นเสียบ 5V จาก USB ของคอมพิวเตอร์เข้ากับ Arduino ทันทีที่คุณทำสิ่งนี้คุณจะเห็นไฟ LED สว่างขึ้น

ฉันรู้ว่ามันค่อนข้างธรรมดา แต่มันก็เป็นเรื่องดีเสมอที่จะเริ่มตั้งแต่ต้น มั่นใจได้ว่าสิ่งต่างๆจะเริ่มน่าสนใจมากขึ้นเรื่อย ๆ เมื่อเราก้าวไปข้างหน้า

1.5 การควบคุม LED ด้วย Arduino

ตอนนี้เราจะเรียนรู้วิธีการควบคุม LED ด้วยโปรแกรม Arduino

ในการเขียนโปรแกรมเราต้องมีอย่างน้อย 2 ฟังก์ชันในแต่ละโปรแกรม

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

ติดตั้ง() สิ่งนี้ถูกเรียกหรือดำเนินการในช่วงเริ่มต้นของโปรแกรม
วน () สิ่งนี้เรียกว่าหรือดำเนินการซ้ำ ๆ ในช่วงระยะเวลาการทำงานทั้งหมดของ Arduino

ดังนั้นแม้ว่ามันอาจไม่มีฟังก์ชันการใช้งานจริง แต่ในทางเทคนิคแล้วโปรแกรม Arduino ที่ถูกต้องตามกฎหมายสามารถเขียนได้โดย:

โปรแกรมที่ง่ายที่สุด

void setup() { } void loop() { }

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

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

นี่เป็นโปรแกรมพื้นฐานที่สุดที่สามารถเขียนและนำไปใช้เพื่อระบุการทำงานที่ถูกต้องของระบบ

เราจะพยายามนำไปใช้และทำความเข้าใจขั้นตอนนี้ผ่านโค้ดต่อไปนี้:

รายการ 1.2: led1 / led1.pde

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

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

const int kPinLed = 13

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

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

void setup() { pinMode(kPinLed, OUTPUT) }

รหัสนี้กำหนดค่าพินเฉพาะที่ LED ของเราเชื่อมต่อ กล่าวอีกนัยหนึ่งโค้ดจะบอกให้ Arduino ควบคุมด้าน 'การเขียน' บนพินนี้แทนที่จะ 'อ่าน'

void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

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

ในที่นี้คำว่า HIGH หมายถึงการรับ + 5V บนพินที่เกี่ยวข้องของ Arduino คำเสริม LOW เพียงแค่ระบุศูนย์หรือ 0V บนพินที่กำหนด

ต่อไปเราเรียก delay() ซึ่งมีหน้าที่สร้างความล่าช้าเป็นมิลลิวินาที (1 / 1000th of a second) เมื่อป้อนตัวเลข 500 ความล่าช้าที่ดำเนินการจะอยู่ที่ 1/2 วินาที

ทันทีที่ผ่านไป 1/2 วินาทีบรรทัดถัดไปจะถูกดำเนินการซึ่งจะปิด LED โดยใช้คำว่า LOW บนพินเดียวกัน

บรรทัดต่อมาจะสร้างการหน่วงเวลา 1/2 วินาทีอีกครั้งเพื่อให้ LED ยังคงดับเป็นเวลา 1/2 วินาที

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

ก่อนที่จะดำเนินการต่อในระดับถัดไปฉันขอแนะนำให้คุณตั้งโปรแกรมโค้ดด้านบนและตรวจสอบว่าคุณสามารถใช้ลำดับ LED ON / OF ได้อย่างถูกต้องหรือไม่

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

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

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

1.7 ความคิดเห็น

บรรทัดของรหัสที่เราเข้าใจข้างต้นเขียนขึ้นสำหรับซอฟต์แวร์คอมพิวเตอร์โดยเฉพาะ

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

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

ภาษาของความคิดเห็นเหล่านี้เขียนด้วยสองรูปแบบ:

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

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

/ * นี่คือ * /

/ * และ
* นี้
* เช่น
* อืม * /

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

// นี่คือความคิดเห็นที่คอมพิวเตอร์จะเพิกเฉย

นี่คือตัวอย่างสำหรับการอ้างอิง:

/* * Program Name: Blink * Author: Alan Smith * Description: * Turns an LED on for one half second, then off for one half second repeatedly. */

/* Pin Definitions */ const int kPinLed = 13 /* * Function Name: setup * Purpose: Run once when the system powers up. */ void setup() { pinMode(kPinLed, OUTPUT) } /* * Function name: loop * Purpose: Runs over and over again, as long as the Arduino has power */ void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

1.8 การแก้ไขปัญหา

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

ภาษาโปรแกรมของคุณจะพิจารณาตัวพิมพ์เล็กและใหญ่ ตัวอย่างเช่นนิพจน์ myVar ไม่สามารถเขียนเป็นไฟล์ MyVar
ช่องว่างสีขาวทุกชนิดที่อาจดำเนินการโดยการพิมพ์แป้นพิมพ์ของคุณในที่สุดจะแสดงเป็นช่องว่างเดียวและคุณเท่านั้นที่มองเห็นหรือเข้าใจคอมพิวเตอร์จะไม่คำนึงถึงสิ่งนี้ พูดง่ายๆคือช่องว่างทุกประเภทจะไม่มีผลใด ๆ กับผลลัพธ์ของโค้ด
แต่ละบล็อกของรหัสจะต้องอยู่ในวงเล็บปีกกาซ้ายและขวา '{' และ '}'
ไม่ควรคั่นหลักตัวเลขด้วยลูกน้ำ ตัวอย่างเช่น 1,000 อาจไม่สามารถเขียนเป็น 1,000 ได้
ทุกบรรทัดรหัสที่อยู่ระหว่างวงเล็บปีกกาต้องลงท้ายด้วยอัฒภาค

การสร้างลำดับแสง LED ที่น่าสนใจด้วย Arduino

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

ตอนนี้เราจะเรียนรู้ว่ารูปแบบการหน่วงเวลาที่แตกต่างกันสามารถดำเนินการบน LED เดียวกันได้อย่างไรโดยการอัปเกรดโค้ดโปรแกรม

เราจะไม่ใช้ LED ภายนอก แต่จะใช้ LED เริ่มต้นในบอร์ด Arduino ที่ขา # 13 คุณจะพบ LED SMD เล็ก ๆ นี้อยู่ด้านหลังขั้วต่อ USB

2.2 การทำความเข้าใจคำสั่ง IF

ในส่วนนี้เราจะเรียนรู้ว่าโครงสร้างการควบคุมช่วยให้เราเรียกใช้รหัสแต่ละรหัสได้อย่างไรและบางครั้งอาจทำซ้ำ ๆ ได้ตามต้องการ

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

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

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

รหัสระหว่างบรรทัดที่ 1 และ 7 นั้นเหมือนกับโปรแกรมเริ่มต้นของเราทุกประการ

การปรับเปลี่ยนครั้งแรกเกิดขึ้นจริงในบรรทัดที่ 8

int delayTime = 1000

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

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

ในตัวอย่างด้านบนคุณจะเห็นว่าตัวแปรนี้มีค่าเท่ากับ 1000 โปรดจำไว้ว่าตัวแปรดังกล่าวที่อยู่ในวงเล็บปีกกาจะต้องเขียนอย่างเคร่งครัดภายในวงเล็บปีกกาคู่เท่านั้นและเรียกว่าตัวแปร 'local'

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

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

delayTime = delayTime - 100

ในรหัสนี้เราจะเห็นว่าค่าเริ่มต้นของไฟล์ เวลาล่าช้า กำลังแก้ไขโดยการลบ 100 ออกจากมัน

ความหมาย 100 จะถูกหักออกจากค่าเริ่มต้นของ 1,000 โดยให้ค่าใหม่เป็น 900

จากภาพต่อไปนี้เราจะพยายามทำความเข้าใจตัวดำเนินการทางคณิตศาสตร์บางตัวที่ใช้ในภาษา Arduino

ตอนนี้เรามาประเมินรหัสระหว่างบรรทัดที่ 13 และ 15

if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 }

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

เนื่องจากว่า 100 จะถูกหักจากเดิม เวลาล่าช้า ป้องกันไม่ให้ไฟ LED กะพริบถึงศูนย์และปล่อยให้การกะพริบอย่างต่อเนื่อง

ภาพต่อไปนี้แสดงตัวดำเนินการเปรียบเทียบบางตัวที่เราจะใช้ในรหัสของเรา:

ตัวดำเนินการเปรียบเทียบสำหรับรหัส arduino

ในโค้ดด้านบนของเราเราสามารถทดสอบโค้ดเป็น if(delayTime == 0) ได้

อย่างไรก็ตามเนื่องจากการเป็นคนคิดลบอาจเป็นเรื่องที่แย่พอ ๆ กันเราจึงไม่ไปหามันและนี่คือแนวทางปฏิบัติที่แนะนำ

ลองคิดดูว่าจะเป็นอย่างไรถ้าเราพยายามหัก 300 แทน 100 จาก delayTime?

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

digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime)

4 บรรทัดสุดท้ายของรหัสตามที่แสดงด้านบนมีหน้าที่ในการเปิด / ปิด LED, เปิด / ปิดอย่างต่อเนื่อง

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

2.3 คำสั่ง ELSE

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

ขออภัยหากฟังดูสับสนเกินไปไม่ต้องกังวลเราจะพยายามทำความเข้าใจกับตัวอย่างต่อไปนี้:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { if(delayTime <= 100){ // If it is less than or equal to 100, reset it delayTime = 1000 } else{ delayTime = delayTime - 100 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

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

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

2.4 คำสั่ง WHILE

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

ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจสิ่งนี้ได้ดีขึ้น

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { while(delayTime > 0){ // while delayTime is greater than 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 } while(delayTime <1000){ // while delayTime is less than 1000 delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) } }

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

2.5 อะไรคือความจริงและเท็จ?

ในภาษาโปรแกรม เท็จ หมายถึงศูนย์ (0) ที่จริงไม่ได้ใช้ 'จริง' แต่จะถือว่าเมื่อไม่มีอะไรเป็นเท็จสิ่งที่รวมอยู่นั้นเป็นจริงแทน

มันดูแปลก ๆ เล็กน้อย แต่มันก็ทำได้ดีทีเดียว

เราจะพยายามเข้าใจสถานการณ์ด้วยตัวอย่างต่อไปนี้

บางครั้งคุณอาจพบรหัสตามที่ระบุด้านล่าง:

while (1){ digitalWrite(kPinLed, HIGH) delay(100) digitalWrite(kPinLed, LOW) delay(100) }

รหัสนี้ดูเหมือนว่าการทำงานของ LED จะหมุนตลอดไปเนื่องจากมีพลังงานที่ยาวนาน

อย่างไรก็ตามข้อเสียอย่างหนึ่งของรหัสประเภทนี้อาจเกิดขึ้นเมื่อผู้ใช้ใช้ a = แทน == โดยไม่ได้ตั้งใจ

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

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

จากนั้นรหัสจะปรากฏดังนี้:

int delayTime = 1000 void loop() { if(delayTime = 0){ // WRONG!!! the = should have been == delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 }

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

แบบนี้ดูไม่ถูกใจ !!

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

2.6 ชุดค่าผสม

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

การใช้การรวมกันของคำศัพท์เชิงตรรกะสามารถทำได้ 3 วิธีดังแสดงในตารางต่อไปนี้:

เป็นเรื่องน่าสนใจที่จะทราบว่าตัวดำเนินการ NOT สามารถทำงานเป็นตัวสลับสำหรับตัวแปรซึ่งอาจถูกกำหนดให้เป็นอย่างใดอย่างหนึ่ง จริง หรือ เท็จ (หรือต่ำหรือสูง)

ตัวอย่างต่อไปนี้แสดงเงื่อนไข:

int ledState = LOW void loop() { ledState = !ledState // toggle value of ledState digitalWrite(kPinLed, ledState) delay(1000) }

นี่คือ ledState จะเป็น LOW และต่อมาทันทีที่ ledState = !ledState จะเปลี่ยนเป็น HIGH ลูปต่อไปนี้จะทำให้เกิด ledState จะสูงเมื่อ ledState = !ledState อยู่ในระดับต่ำ.

2.7 สำหรับงบ

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

มาทำความเข้าใจกับตัวอย่างต่อไปนี้:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { for(int i = 0 i <4 i++){ digitalWrite(kPinLed, HIGH) delay(200) digitalWrite(kPinLed, LOW) delay(200) } delay(1000) // 1 second }

คุณสามารถค้นหาสิ่งที่ไม่เหมือนใครในบรรทัดด้วย สำหรับ.

มันคือรหัส ผม ++? . สิ่งนี้มีประโยชน์สำหรับโปรแกรมเมอร์ที่ค่อนข้างขี้เกียจและต้องการใช้การเข้ารหัสผ่านทางลัดที่สะดวก

คำศัพท์ข้างต้นเรียกว่าตัวดำเนินการผสมเนื่องจากทำหน้าที่ในการรวมตัวดำเนินการกำหนดหนึ่งตัวกับตัวดำเนินการมอบหมายอื่น สิ่งที่ได้รับความนิยมมากที่สุดสามารถดูได้จากตารางต่อไปนี้:

คุณจะพบว่ามี 3 คำสั่งย่อยในคำสั่ง for มีโครงสร้างตามที่แสดงด้านล่าง:

for (statement1conditionstatement2){ // statements }

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

การเชื่อมต่อ LED เพิ่มเติม

ตกลงตอนนี้เราจะมาดูกันว่าเราสามารถเชื่อมต่อ LEds จำนวนมากขึ้นเพื่อให้ได้เอฟเฟกต์ที่น่าสนใจมากขึ้น

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

ตอนนี้เรามาแก้ไขโปรแกรมที่จะช่วยให้เราตรวจสอบว่าฮาร์ดแวร์ของเราได้รับการกำหนดค่าอย่างถูกต้องหรือไม่

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

ซึ่งจะช่วยแก้ไขข้อผิดพลาดที่อาจเกิดขึ้นได้อย่างรวดเร็ว

ตัวอย่างโค้ดด้านล่างให้ LED 2 ถึง 5 เป็นรูปแบบเฉพาะโดยเปลี่ยนทีละรูปแบบเป็นวงจร

const int kPinLed1 = 2 const int kPinLed2 = 3 const int kPinLed3 = 4 const int kPinLed4 = 5 void setup() { pinMode(kPinLed1, OUTPUT) pinMode(kPinLed2, OUTPUT) pinMode(kPinLed3, OUTPUT) pinMode(kPinLed4, OUTPUT) } void loop() { // turn on each of the LEDs in order digitalWrite(kPinLed1, HIGH) delay(100) digitalWrite(kPinLed2, HIGH) delay(100) digitalWrite(kPinLed3, HIGH) delay(100) digitalWrite(kPinLed4, HIGH) delay(100) // turn off each of the LEDs in order digitalWrite(kPinLed1, LOW) delay(100) digitalWrite(kPinLed2, LOW) delay(100) digitalWrite(kPinLed3, LOW) delay(100) digitalWrite(kPinLed4, LOW) }

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

แน่นอนว่ามีวิธีที่ดีกว่าในการเขียนโค้ดด้านบนส่วนต่อไปนี้จะเปิดเผย

2.9 การแนะนำอาร์เรย์

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

const int k_numLEDs = 4 const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5 void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } } void loop() { for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) } for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) } }

ตกลงตอนนี้เรามาดูแต่ละส่วนและทำความเข้าใจว่ามันทำงานอย่างไร

const int k_numLEDs = 4

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

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

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

เมื่อคุณพบอาร์เรย์ที่สร้างดัชนีด้วยหมายเลข 0 สิ่งนี้บ่งชี้ถึงองค์ประกอบแรกในอาร์เรย์ดังที่แสดงใน code: k_LEDPins is k_LEDPins[0]

ในทำนองเดียวกันองค์ประกอบสุดท้ายจะแสดงเป็น k_LEDPins[3] เนื่องจากการนับจาก 0 ถึง 3 คือ 4

void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } }

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

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

ต่อไปเรามาดูกันว่าโค้ดบล็อกถัดไปทำอะไร:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) }

ที่นี่รหัสจะดำเนินการผ่าน LED แต่ละดวงเพื่อเปิดสวิตช์ตามลำดับโดยมีช่องว่างหรือหน่วงเวลา 100 มิลลิวินาที

for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) }

การใช้โค้ดด้านบนแสดงให้เห็นว่าแอปพลิเคชันของ สำหรับห่วง สามารถใช้เพื่อเลื่อนผ่านลูปได้แม้ในลำดับย้อนกลับ

เริ่มต้นจาก k_numLEDs - 1 เนื่องจากอาร์เรย์เป็นศูนย์ เราไม่ได้เริ่มต้นจาก k_LEDPins[4] เพราะนั่นจะส่งผลให้ข้ามจุดสิ้นสุดของอาร์เรย์

รหัสใช้> = 0 เพื่อตรวจสอบเพื่อให้องค์ประกอบแรกที่ดัชนี 0 ไม่พลาดหรือละเลย

บทที่ 3

อินพุตคืออะไร

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

3.1 การใช้ปุ่มกด

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

3.1.1 ปุ่มเดียวและไฟ LED

เราจะเชื่อมต่อ Arduino ด้วยปุ่มกดกับ Arduino ตามรายละเอียดที่แสดงด้านบนและเรียนรู้การทำงานพื้นฐานและการใช้งานการตั้งค่า

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

ในตัวอย่างนี้เราใช้พินหรือที่ติดต่อเหล่านี้เพียงคู่เดียวส่วนอีกคู่ไม่เกี่ยวข้องจึงถูกเพิกเฉย

มาดำเนินการต่อโดยใช้รหัสต่อไปนี้และตรวจสอบว่าใช้งานได้!

const int kPinButton1 = 2 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

คุณอาจพบบางสิ่งที่ดูผิดปกติที่นี่ ลองหาขั้นตอนที่ชาญฉลาด

void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) }

สิ่งแรกที่เราทำคือแก้ไขไฟล์ buttonPin เป็น อินพุต. มันค่อนข้างธรรมดาฉันรู้

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

ที่จริงแล้วการกำหนด HIGH ให้กับอินพุต Arduino จะสลับตัวต้านทานแบบดึงขึ้น 20k Ohm ภายใน (LOW บนพินนี้จะสลับเป็น OFF)

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

ตกลงไปต่อตอนนี้เรามาดูรหัสลูปหลัก:

void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

เมื่อคุณกดปุ่มกดพินแบบมีสายจะเชื่อมต่อกับกราวด์ซึ่งจะแสดงผล a ต่ำ ไปที่พินนั้น และในขณะที่อยู่ในสภาพที่ไม่ถูกบีบอัดจะมีการตรึงพินเดียวกันไว้ที่ สูง หรือ + 5V ผ่านตัวต้านทานแบบดึงขึ้นภายใน 20K

ที่นี่เราต้องการให้ Arduino ส่องสว่าง LED เมื่อกดปุ่ม (LOW) ดังนั้นเราจึงเขียน HIGH สำหรับเอาต์พุตสำหรับทุกการตอบสนองของ LOW จากปุ่มกดในขณะที่กด

3.1.2 ปุ่มสองปุ่มและไฟ LED

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

จนถึงจุดนี้เราได้ศึกษาการเขียนโค้ดสำหรับสวิตช์เปิด (สูง) หรือปิด (ต่ำ) ของ LED

ตอนนี้เรามาดูกันว่าสามารถควบคุมความสว่างของ LED ด้วย Arduino ได้อย่างไร

อาจทำได้โดยใช้สองวิธี:

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

ในบอร์ด Arduino รองรับ PWM บนพินที่มีเครื่องหมายทิลเดอ (~) ซึ่ง ได้แก่ พิน 3, 4,5,9,10 และ 11) ที่ 500Hz (500 ครั้งต่อวินาที) ผู้ใช้สามารถระบุค่าใด ๆ ระหว่าง 0 ถึง 255 โดยที่ 0 หมายถึงไม่สูงหรือไม่ + 5V และ 255 บอกให้ Arduino รับ HIGH หรือ + 5V ตลอดเวลา สำหรับการเริ่มต้นคำสั่งเหล่านี้คุณจะต้องเข้าถึง analogWrite () ด้วยค่าที่ต้องการ

คุณอาจถือว่า PWM เป็น x / 255 โดยที่ x คือค่าที่คุณต้องการส่งผ่าน analogWrite()

ตั้งค่า Arduino และพารามิเตอร์อื่น ๆ ตามที่แสดงด้านบน

const int kPinButton1 = 2 const int kPinButton2 = 3 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) pinMode(kPinButton2, INPUT) pinMode(kPinLed, OUTPUT) digitalWrite(kPinButton1, HIGH) // turn on pullup resistor digitalWrite(kPinButton2, HIGH) // turn on pullup resistor } int ledBrightness = 128 void loop() { if(digitalRead(kPinButton1) == LOW){ ledBrightness-- } else if(digitalRead(kPinButton2) == LOW){ ledBrightness++ } ledBrightness = constrain(ledBrightness, 0, 255) analogWrite(kPinLed, ledBrightness) delay(20) }

คุณอาจพบ 3 บรรทัดที่นี่ต้องการคำอธิบาย

ledBrightness = constrain(ledBrightness, 0, 255) 25 analogWrite(kPinLed, ledBrightness) 26 delay(20)

บรรทัด: ledBrightness = constrain(ledBrightness, 0, 255) แสดงฟังก์ชันเฉพาะภายใน Arduino ที่เรียกว่า constrain ()

ฟังก์ชันภายในนี้ประกอบด้วยรหัสที่คล้ายกับสิ่งต่อไปนี้:

int จำกัด (ค่า int, int min, int max)
{ if(value > max){ value = max } if(value value = min } return value }

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

ถูกต้องหมายความว่ารหัส: ledBrightness = constrain(ledBrightness, 0, 255) กำหนด ledBrightness to be within the range of 0 and 255.

บรรทัดถัดไปมีพนักงาน analogWrite เพื่อสั่งให้ Arduino appply PWM บนพินที่เลือกด้วยค่าที่ต้องการ

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

3.2 โพเทนชิโอมิเตอร์

มาดูวิธีใช้กันเลย โพเทนชิโอมิเตอร์กับ Arduino

หากต้องการทราบว่าโพเทนชิออมิเตอร์หรือหม้อทำงานอย่างไรคุณสามารถอ่านสิ่งนี้ได้ บทความ .

เชื่อมต่อพารามิเตอร์ที่แสดงกับ Arduino ของคุณดังที่แสดงด้านบน

หม้อจะมี 3 ขั้ว เทอร์มินัลกลางจะเชื่อมต่อกับ ANALOG IN 0 บน Arduino อีกสองขั้วด้านนอกอาจเชื่อมต่อกับรางจ่าย + 5V และ 0V

มาตั้งโปรแกรมและตรวจสอบผลลัพธ์:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinPot, INPUT) pinMode(kPinLed, OUTPUT) } void loop() { int ledBrightness int sensorValue = 0 sensorValue = analogRead(kPinPot) ledBrightness = map(sensorValue, 0, 1023, 0, 255) analogWrite(kPinLed, ledBrightness) }

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

ค่าคงที่ kPinPot ถูกกำหนดให้เป็น A0 โดย A เป็นทางลัดในการอธิบายพินอะนาล็อกตัวใดตัวหนึ่ง อย่างไรก็ตาม A0 ยังหมายถึงพิน # 14, A1 ถึงพิน # 15 เป็นต้นและสิ่งเหล่านี้ช่วยให้คุณสามารถใช้เป็นอินพุต / เอาต์พุตดิจิทัลในกรณีที่พินสำหรับการทดสอบหมด แต่จำไว้ว่าคุณไม่สามารถใช้พินดิจิทัลเป็นพินอนาล็อกได้
บรรทัด: ledBrightness = map(sensorValue, 0, 1023, 0, 255) นำเสนอฟังก์ชันภายในใหม่ใน Arduino ที่เรียกว่า แผนที่(). คุณสมบัตินี้จะปรับเทียบใหม่จากช่วงที่กำหนดไปยังอีกช่วงหนึ่งเรียกว่า แผนที่ (value, fromLow, fromHigh, toLow, toHigh) สิ่งนี้อาจกลายเป็นสิ่งสำคัญตั้งแต่ analogueRead ให้ค่าภายในช่วง 0-1023 แต่ analogWrite สามารถรับค่าตั้งแต่ 0-255 ได้

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

ไม่มีปัญหาตอนนี้เราจะทำบางสิ่งที่ไม่สามารถทำได้หากไม่มี Arduino

“ระบบปฏิบัติการสามประเภท ”

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

นี่คือโปรแกรม:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { int sensorValue sensorValue = analogRead(kPinPot) digitalWrite(kPinLed, HIGH) delay(sensorValue) digitalWrite(kPinLed, LOW) delay(sensorValue) }

3.2.3 การหลีกเลี่ยงความล่าช้า ()

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

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } long lastTime = 0 int ledValue = LOW void loop() { int sensorValue sensorValue = analogRead(kPinPot) if(millis() > lastTime + sensorValue){ if(ledValue == LOW){ ledValue = HIGH } else{ ledValue = LOW } lastTime = millis() digitalWrite(kPinLed, ledValue) } }

แล้วโค้ดด้านบนแตกต่างกันอย่างไร? เป็นบรรทัดต่อไปนี้ที่สร้างความแตกต่าง

long lastTime = 0

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

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

คุณสามารถดูฟังก์ชันที่น่าสนใจอื่นที่เรียกว่า มิลลิวินาที ().

สิ่งนี้ก่อให้เกิดช่วงเวลาเป็นมิลลิวินาทีที่ Arduino ทำงานในช่วงการทำงานตั้งแต่เริ่มต้น (สิ่งนี้จะรีเซ็ตเป็น 0 หลังจากทุกๆ 50 วัน) นี่มันกลับยาวเพราะถ้ามันกลับมา int อาจไม่สามารถนับเป็นระยะเวลานานได้ คุณช่วยตอบได้ไหมว่านานแค่ไหน? คำตอบคือ 32.767 วินาที

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

ไฟ LED RGB 3.3

จนถึงตอนนี้เราได้เล่นกับ LED สีเดียว แม้ว่าสี LED สามารถเปลี่ยนได้โดยการเปลี่ยน LED เป็นสีอื่น แต่วิธีการใช้ LED RGB เพื่อเปลี่ยนสี LED โดยไม่ต้องเปลี่ยนไฟ LED?

RGB LED เป็น LED ที่มี LED สีแดงสีเขียวและสีน้ำเงินฝังอยู่และรวมเป็น LED เดียว มีตะกั่วทั่วไปหนึ่งตัวซึ่งไปที่พื้นหรือรางจ่าย 0V ในขณะที่อีก 3 สายการบินจะถูกป้อนด้วยสัญญาณบวก PWM ที่หลากหลายสำหรับการดำเนินการตามที่ตั้งใจไว้ การผสมสี .

คุณสามารถวางสายการตั้งค่าดังที่แสดงด้านล่าง:

อาจดูซับซ้อนเล็กน้อย แต่จริงๆแล้วมันเป็นแบบจำลองของการออกแบบการควบคุม LED รุ่นก่อนหน้าของเราโดยใช้ PWM

นี่คือรหัสโปรแกรมแบบฝึกหัด:

const int kPinPot1 = A0 const int kPinPot2 = A1 const int kPinPot3 = A2 const int kPinLed_R = 6 const int kPinLed_G = 10 const int kPinLed_B = 11 void setup() { pinMode(kPinLed_R, OUTPUT) pinMode(kPinLed_G, OUTPUT) pinMode(kPinLed_B, OUTPUT) } void loop() { int potValue int ledValue potValue = analogRead(kPinPot1) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_R, ledValue) potValue = analogRead(kPinPot2) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_G, ledValue) potValue = analogRead(kPinPot3) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_B, ledValue) }

หลังจากอัปโหลดโค้ดนี้แล้วเพียงแค่ดูว่าการปรับแต่งหม้อสร้างเอฟเฟกต์แสงที่น่าสนใจบน RGB ได้อย่างไรมันอาจเป็นเรื่องสนุก

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

เสียงกับ Arduino

ในส่วนนี้เราจะเรียนรู้วิธีเพิ่มเสียงและเพลงพื้นฐานในการตั้งค่า Arduino

เราจะดูวิธีการเปลี่ยนสัญญาณไปยังลำโพงที่เชื่อมต่อด้วยความถี่ที่ต้องการ

เพื่อให้แม่นยำยิ่งขึ้นจะมีการทดลองใช้โน้ตกลางซึ่งเป็นโน้ตความถี่ 440 เฮิรตซ์

ในการทำเช่นนี้เราจะเล่นโน้ต A กลางและปรับสัญญาณคลื่นไซน์ด้วยคลื่นสี่เหลี่ยมให้เหมาะสม

นอกจากนี้เราจะคำนวณระยะเวลาที่ลำโพงอาจเปิดอยู่โดยการฟ้องร้องสูตร:

timeDelay = 1 วินาที / 2 x toneFrequency

timeDelay = 1 วินาที / 2 x 440

timeDelay = 1136 ไมโครวินาที

4.1 มาต่อบอร์ด Arduino กันเถอะ

4.2 การเพิ่มบันทึกย่ออย่างง่าย

เราได้พูดคุยเกี่ยวกับฟังก์ชันแล้ว ล่าช้า () โดยที่หน่วยเป็นมิลลิวินาที (วินาที / 1,000) อย่างไรก็ตามคุณจะพบฟังก์ชันอื่น delayMicroseconds() โดยที่หน่วยเป็นไมโครวินาที (มิลลิวินาที / 1,000)

สำหรับการตั้งค่าปัจจุบันเราตั้งรหัสเพื่อสลับ + 5V เปิด / ปิดบนพินที่เลือกซึ่งเชื่อมโยงกับลำโพงในอัตรา 440 พัลส์ต่อวินาที

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

นี่คือโปรแกรมสำหรับสิ่งนี้ซึ่งจะช่วยให้คุณได้ยินเสียงบันทึกที่ 440 Hz ทันทีที่คุณตั้งโปรแกรม arduino โดยเชื่อมต่อกับลำโพง

const int kPinSpeaker = 9 const int k_timeDelay = 1136 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { digitalWrite(kPinSpeaker, HIGH) delayMicroseconds(k_timeDelay) digitalWrite(kPinSpeaker, LOW) delayMicroseconds(k_timeDelay) }

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

จากรหัสเราเข้าใจว่า Arduino มีฟังก์ชันบูรณาการสองสามอย่างซึ่งมีส่วนช่วยในการสร้างเพลงเพิ่มเติม

คนแรกคือ โทน() ซึ่งทำงานร่วมกับ 2 องค์ประกอบพร้อมกับองค์ประกอบทางเลือกที่ 3 ซึ่งกำหนดให้เป็น โทน (พินความถี่ระยะเวลา) หรือ โทน (พินความถี่)

ทั้งสองได้รับการกำหนดให้ดำเนินการตามช่วงเวลาที่คุณกำหนด

ในช่วงเวลาที่ไม่มีเพลงจะเล่นต่อไปจนกว่าจะมีการโทร โทน() จะถูกดำเนินการอีกครั้งหรือจนกว่าคุณจะดำเนินการ ไม่มี ()

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

ระยะเวลาอาจมีความสำคัญเนื่องจากช่วยให้สามารถระบุระยะเวลาที่เล่นเพลงได้ดังนั้นคุณจึงมีอิสระที่จะทำอย่างอื่นได้ ทันทีที่หมดระยะเวลาเพลงจะหยุดลง

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

คำเตือนที่แปลกประหลาด: ทุกเมื่อ โทน() มีการใช้งานฟังก์ชัน PWM บนพิน 3 และ 11 จะหยุดทำงาน

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

ตกลงนี่คือโปรแกรมสำหรับการใช้งานเพลงบนลำโพงแม้ว่ามันจะไม่ใช่เพลงจริง แต่เป็นโน้ต C ระดับพื้นฐาน

#define NOTE_C4 262 #define NOTE_D4 294 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_G4 392 #define NOTE_A4 440 #define NOTE_B4 494 #define NOTE_C5 523 const int kPinSpeaker = 9 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { tone(kPinSpeaker, NOTE_C4, 500) delay(500) tone(kPinSpeaker, NOTE_D4, 500) delay(500) tone(kPinSpeaker, NOTE_E4, 500) delay(500) tone(kPinSpeaker, NOTE_F4, 500) delay(500) tone(kPinSpeaker, NOTE_G4, 500) delay(500) tone(kPinSpeaker, NOTE_A4, 500) delay(500) tone(kPinSpeaker, NOTE_B4, 500) delay(500) tone(kPinSpeaker, NOTE_C5, 500) delay(500) noTone(kPinSpeaker) delay(2000) }

ในโค้ดด้านบนคุณอาจสังเกตเห็นสิ่งใหม่ ๆ และนั่นคือ #กำหนด .

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

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

ดังนั้นในตัวอย่างนี้เมื่อคอมพิวเตอร์เห็น NOTE_E4 มันแทนที่อย่างรวดเร็วด้วยปริมาณ 330

สำหรับบันทึกและการปรับแต่งเพิ่มเติมคุณสามารถอ้างถึงไฟล์ในแท่ง USB ของคุณที่ชื่อ สนาม h ซึ่งความถี่ส่วนใหญ่สามารถพบได้ตามความต้องการของคุณ

4.4 เพลงพร้อมฟังก์ชั่น

โค้ดด้านบนดูดี แต่ดูเหมือนว่าจะมีการทำซ้ำหลายวิธีควรมีวิธีการบางอย่างในการย่อการทำซ้ำเหล่านี้ใช่ไหม?

จนถึงตอนนี้เราได้ทำงานร่วมกับฟังก์ชันสำคัญสองอย่างที่มาพร้อมกับ Arduino ตอนนี้อาจถึงเวลาที่เราสร้างฟังก์ชันของเราเอง

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

ดังนั้นชื่อฟังก์ชันเฉพาะจึงได้รับวงเล็บเปิด '(' ตามด้วยรายการพารามิเตอร์ที่คั่นด้วยจุลภาค

พารามิเตอร์แต่ละตัวได้มาซึ่งประเภทพร้อมกับชื่อและในที่สุดก็ปิด ')' วงเล็บ.

พารามิเตอร์เหล่านี้สามารถนำไปใช้ภายในฟังก์ชันในรูปแบบของตัวแปร

ลองดูตัวอย่างด้านล่างที่เราพัฒนาฟังก์ชันที่เรียกว่า ของเราโทน () ออกแบบมาเพื่อรวมไฟล์ โทน() ด้วย ล่าช้า () ในลักษณะที่ฟังก์ชั่นหยุดย้อนกลับจนกว่าโน้ตจะเล่นโทนเสร็จ

เราใช้ฟังก์ชันเหล่านี้ในโค้ดก่อนหน้าของเราและรับโปรแกรมด้านล่างดูบรรทัดสุดท้าย:

ฟังก์ชันต่างๆมีประโยชน์อย่างยิ่งในการทำให้โปรแกรมเข้าใจง่ายขึ้น

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

#include 'pitches.h' int kPinSpeaker = 9 #define NUM_NOTES 15 const int notes[NUM_NOTES] = // a 0 represents a rest { NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, 0 } const int beats[NUM_NOTES] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 } const int beat_length = 300 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { for (int i = 0 i if (notes[i] == 0) { delay(beats[i] * beat_length) // rest } else { ourTone(notes[i], beats[i] * beat_length) } // pause between notes noTone(kPinSpeaker) delay(beat_length / 2) } } void ourTone(int freq, int duration) { tone(kPinSpeaker, freq, duration) delay(duration) }

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

บทที่ 5

การวัดอุณหภูมิ

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

5.1 Serial Monitor

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

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

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

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) Serial.begin(9600) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If it would have been zero or less, reset it. delayTime = 1000 } Serial.print('delayTime = ') Serial.println(delayTime) digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

คุณสามารถระบุสองสิ่งใหม่ที่นี่บรรทัดใหม่ในไฟล์ ติดตั้ง() ฟังก์ชัน

Serial.begin(9600)

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

รายการใหม่ที่สองมีดังนี้

Serial.print('delayTime = ') Serial.println(delayTime)

บรรทัดที่สองแสดงให้เห็นว่าสิ่งที่ตามมาจากพอร์ตอนุกรมจะเริ่มต้นในบรรทัดถัดไป นั่นเป็นวิธีที่บรรทัดที่สองแตกต่างจากเส้นกำปั้น

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

ตกลงตอนนี้เราสามารถอัปโหลดโค้ดด้านบนใน Arduino และดูว่าเกิดอะไรขึ้น

อะไรโอ๊ะดูเหมือนว่าจะไม่มีอะไรเกิดขึ้น LED ขา Arduino # 13 กะพริบและหยุดในขณะที่ LED Tx กะพริบ

นั่นเป็นเพราะหน้าต่าง Serial Monitor ยังไม่ได้รับการแก้ไข

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

คลิปวิดีโอต่อไปนี้จะอธิบายถึงวิธีการทำ

https://youtu.be/ENg8CUyXm10

ตอนนี้เรามาดูกันว่าคุณลักษณะ Serial Monitor ข้างต้นสามารถช่วยในการประมวลผลไฟล์ การวัดอุณหภูมิโดยใช้ Arduino

เราจะใช้ IC TMP36 เป็นเซ็นเซอร์อุณหภูมิโดยมีช่วง -40 ถึง 150 องศาเซลเซียส

การตั้งค่าสามารถดูได้ด้านล่าง:

TMP36 พร้อม Arduino สำหรับการวัดอุณหภูมิ

รหัสต่อไปนี้จะเริ่มต้นการวัดอุณหภูมิโดยการอ่านเอาต์พุตจากเซ็นเซอร์ TMP36 และส่งไปยังมอนิเตอร์แบบอนุกรมของ ID

const int kPinTemp = A0 void setup() { Serial.begin(9600) } void loop() { float temperatureC = getTemperatureC() Serial.print(temperatureC) Serial.println(' degrees C') // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) Serial.print(temperatureF) Serial.println(' degrees F') delay(500) } float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

มาทำความเข้าใจรหัสจากด้านบน

float temperatureC = getTemperatureC()

ที่นี่คุณจะเห็นว่าเราได้รวมประเภทตัวแปรไว้ ลอย.

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

ความแม่นยำจากตัวแปร float สามารถมีได้ไม่เกิน 6 ถึง 7 หลัก

รหัสที่อยู่ติดกัน getTemperatureC() เป็นฟังก์ชันของเราเองซึ่งคำนวณทางคณิตศาสตร์และแปลงความแตกต่างของแรงดันไฟฟ้าที่ตรวจจับได้จากเซ็นเซอร์ TMP36 เป็นองศาเซลเซียส

float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 }

ในส่วนถัดไปของรหัสตั้งแต่คำว่า analogIn() ถูกกำหนดให้ส่งกลับตัวเลขระหว่าง 1 ถึง 1023 เป็นไปได้ที่เราจะประเมินแรงดันไฟฟ้าจากเซ็นเซอร์โดยการคูณการอ่านของเราด้วย 5 แล้วหารด้วย 1024

เซ็นเซอร์ TMP36 ถูกระบุให้สร้าง 0.5V ที่ 0 องศาเซลเซียสและต่อมาจะสร้าง 10mV สำหรับการเพิ่มขึ้นทุกครั้งในองศาเซลเซียส

นี่คือค่าประมาณที่เราสามารถสร้างได้จากการคำนวณ:

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

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

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

เมื่อสิ่งนี้ถูกส่งไปยัง Serial Monitor การอ่านจะถูกแปลงเป็นฟาเรนไฮต์ผ่าน ConvertToF ()

float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

ฟังก์ชันนี้จะรับช่วงเซลเซียสและแปลงเป็นฟาเรนไฮต์

สำหรับการแปลงฟาเรนไฮต์เป็นเซลเซียสเราใช้สูตร ฟาเรนไฮต์ = 9 / 5 (เซลเซียส) + 32

5.3 การเชื่อมต่อ LCD

ตอนนี้เรามาศึกษาวิธีการเชื่อมต่อหรือเชื่อมต่อไฟล์ จอ LCD ด้วย Arduino สำหรับการแสดงผลภาพสำหรับเอาต์พุตที่ต้องการ

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

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

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

นอกจากนี้คุณยังสามารถดู 8 pinouts จากโมดูล LCD ข้อมูลจำเพาะของ pinout สามารถศึกษาได้จากตารางต่อไปนี้:

ตอนนี้เรามาดูกันว่าเราจะเชื่อมต่อ LCD และพารามิเตอร์ที่เกี่ยวข้องกับ Arduino ของเราได้อย่างไร รายละเอียดสามารถมองเห็นได้จากภาพประกอบด้านล่าง:

5.4 การสื่อสารกับ LCD

แม้ว่าจะเป็นไปได้ที่จะเขียน coeds อย่างละเอียดสำหรับการโต้ตอบกับ LCD จาก Arduino แต่เราก็ค่อนข้างจะเรียนรู้วิธีการทำเช่นเดียวกันโดยใช้ไลบรารี

ไลบรารีประกอบด้วยรหัสหลายประเภทที่สามารถนำไปใช้กับโปรแกรม Arduino ที่เลือกได้อย่างรวดเร็ว

ทำให้ผู้ใช้สามารถเรียกใช้ฟังก์ชันได้อย่างง่ายดายโดยไม่ต้องผ่านการเข้ารหัสที่ซับซ้อน

5.4.1 วิธีติดตั้งไลบรารี

สำหรับสิ่งนี้คุณจะต้องสร้างไดเร็กทอรีที่เรียกว่าไลบรารีในคอมพิวเตอร์ Arduino IDE ตามที่อธิบายไว้ ที่นี่

5.4.2 การปรับใช้การทำงานของ LCD

“วิธีทำเครื่องชาร์จแบตเตอรี่ 18v ”

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

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') } void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

บรรทัดมีรหัส #include

รหัส #include สั่งให้พีซีรับไฟล์ที่กล่าวถึงและแทนที่องค์ประกอบ #include ด้วยเนื้อหาของไฟล์ในระหว่างการคอมไพล์โปรแกรม

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

บรรทัดถัดมาของโค้ดจะแสดงพินของ LCD จากนั้นเราจะเขียนตัวแปรรูปแบบใหม่:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

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

ในขั้นตอนนี้เราจะอธิบายตัวแปรไปยังพีซีโดยสั่งให้พิน clk, din, dc และรีเซ็ตเชื่อมต่อกับ Arduino อย่างไร

void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') }

บรรทัด lcd.init() เริ่มต้นการทำงานของ LCD เมื่อดำเนินการแล้วบรรทัดถัดไปจะบังคับใช้เคอร์เซอร์ที่ด้านซ้ายบนของจอแสดงผล และบรรทัดถัดไปจะพยายามพิมพ์ข้อความ 'Hello, World'

ลักษณะนี้ค่อนข้างเหมือนกับเทคนิคที่เราส่งข้อความผ่านจอภาพแบบอนุกรม ข้อแตกต่างเพียงอย่างเดียวคือการใช้รหัส lcd.print แทนที่จะเป็น serial.print

รหัสบล็อกถัดไปเรียกว่าซ้ำซาก

void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

โดยใช้บรรทัดนี้ lcd.setCursor(0,1) เราแก้ไขเคอร์เซอร์ไปที่คอลัมน์ 0 ที่ด้านซ้ายสุดของแถวที่ 1 บนจอแสดงผล LCD

บรรทัดถัดไปใช้ทางลัด: lcd.print(millis())

หากคุณจำได้ว่าเราเคยร่วมงานกับ millis() ในรหัสก่อนหน้านี้เราสามารถใช้รหัสเดียวกันนี้ได้เช่นกัน:

long numMillis = millis() lcd.print(numMillis)

อย่างไรก็ตามเนื่องจากความจริงที่ว่าที่นี่ไม่มีช่วงเวลาเป็นมิลลิวินาทีที่เกี่ยวข้องดังนั้นเราจึงทำได้โดยเพียงแค่ส่ง millis() โดยตรงไปยัง lcd.print() .

5.5 การรวมสิ่งต่างๆเข้าด้วยกัน

ตกลงตอนนี้เรามารวมรหัสทั้งหมดที่เราได้เรียนรู้ข้างต้นเพื่อสร้างวงจรอุณหภูมิ LCD แล้วมาดูกันว่ามันเป็นอย่างไร:

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 const int kPin_Temp = A0 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(10,0) lcd.print('Temperature:') } void loop() { float temperatureC = getTemperatureC() // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) lcd.setCursor(21,1) lcd.print(temperatureC) lcd.print(' C') lcd.setCursor(21,2) lcd.print(temperatureF) lcd.print(' F') delay(100) } float getTemperatureC() { int reading = analogRead(kPin_Temp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

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

เยี่ยมมาก! และขอแสดงความยินดีคุณเพิ่งตั้งโปรแกรมตัวบ่งชี้อุณหภูมิ LCD ของคุณเองโดยใช้ Arduino

แอพพลิเคชัน Arduino ที่ใช้งานได้จริง

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

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

7.1 รู้เบื้องต้นเกี่ยวกับเซนเซอร์

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

เราจะเริ่มต้นด้วยการเชื่อมต่อของ LDR เซ็นเซอร์แสง กับ Arduino ดังที่แสดงในแผนภาพต่อไปนี้:

อย่างที่เราทราบกันดีว่า LDR เป็นอุปกรณ์ตัวต้านทานที่ขึ้นกับแสงซึ่งความต้านทานขึ้นอยู่กับความเข้มของเหตุการณ์โดยรอบบนพื้นผิว

ความเข้มของแสงแปรผกผันกับการอ่านค่าความต้านทานของ LDR

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

รหัสโปรแกรมทั้งหมดสามารถมองเห็นได้ตามที่ระบุด้านล่าง:

const int kPin_Photocell = A0 void setup() { Serial.begin(9600) } void loop() { int value = analogRead(kPin_Photocell) Serial.print('Analog Reading = ') Serial.print(value) if(value <200){ Serial.println(' - Dark') }else if(value <400){ Serial.println(' - Dim') } else if(value <600){ Serial.println(' - Light') } else if(value <800){ Serial.println(' - Bright') } else{ Serial.println(' - Very Bright') } delay(1000) }

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

ค่าถูกเลือกแบบสุ่มคุณสามารถเปลี่ยนได้อย่างง่ายดายตามความต้องการของคุณเอง

เซ็นเซอร์เอียง

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

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

const int kPin_Tilt = 3 const int kPin_LED = 13 void setup() { pinMode(kPin_Tilt, INPUT) digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor pinMode(kPin_LED, OUTPUT) } void loop() { if(digitalRead(kPin_Tilt) == HIGH){ digitalWrite(kPin_LED, LOW) } else{ digitalWrite(kPin_LED, HIGH) } }

ในตัวอย่างนี้ไฟ LED เริ่มต้นของพิน # 13 จะใช้เป็นตัวบ่งชี้การเอียง

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

7.4 Reed Switch Relay (รีเลย์เปิดใช้งานแม่เหล็กขนาดเล็ก)

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

เราใช้พิน # 13 LED เพื่อระบุการตอบสนองด้วยเช่นกัน คุณสามารถเชื่อมต่อ LED ภายนอกจากพินนี้ได้หากจำเป็นตามคำอธิบายก่อนหน้านี้ของเรา

const int kPinReedSwitch = 2 const int kPinLed = 13 void setup() pinMode(kPinReedSwitch, INPUT) digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinReedSwitch) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

เงื่อนไขรหัสควรเป็นที่คุ้นเคยและอธิบายได้ด้วยตนเอง

7.5 เซ็นเซอร์ตรวจจับการสั่นสะเทือนโดยใช้ Piezo Transducer

ในโปรแกรมตัวอย่างถัดไปเราจะดูว่าไฟล์ ตัวแปลงสัญญาณ piezo อาจใช้เป็นเซ็นเซอร์ตรวจจับการสั่นสะเทือนเพื่อให้แสงสว่าง LED ผ่าน Arduino

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

ตั้งค่า Arduino และองค์ประกอบ piezo ตามที่ระบุในรูปต่อไปนี้

ใช้ piezo เป็นเซ็นเซอร์ตรวจจับการสั่นสะเทือนกับ Arduino

const int kPinSensor = A5 const int kPinLed = 13 const int k_threshold = 100 int ledState = LOW // variable used to store the last LED status, to toggle the light void setup() { pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT } void loop() { int val = analogRead(kPinSensor) if (val >= k_threshold) { ledState = !ledState // toggle the value of ledState digitalWrite(kPinLed, ledState) delay(20) // for debouncing } }

มีการแนะนำ threshold 100 เพื่อให้แน่ใจว่า Arduino ตอบสนองต่อการสั่นสะเทือนของแท้ผ่านการเคาะเท่านั้นและไม่ใช่การสั่นสะเทือนขนาดเล็กอื่น ๆ เช่นจากเสียงดังหรือแตร

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

ใช้เซอร์โวมอเตอร์กับ Arduino

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

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

Arduino ช่วยอำนวยความสะดวกในการควบคุมเซอร์โวมอเตอร์ผ่านภาษาสนับสนุนในตัวซึ่งทำให้การควบคุมสะดวกและเหมาะสำหรับเซอร์โวมอเตอร์

ตัวอย่างต่อไปนี้จะแสดงโปรแกรมการตั้งค่าพื้นฐานสำหรับการใช้งานการควบคุมเซอร์โวมอเตอร์ผ่าน Arduino:

รหัสได้รับด้านล่าง:

#include Servo servo1 const int kPinPot = A0 const int kPinServo1 = 9 void setup() { servo1.attach(kPinServo1) } void loop() { int val = analogRead(kPinPot) val = map(val, 0, 1023, 0, 180) servo1.write(val) delay(15) }

เราสามารถดูรายการใหม่สองสามรายการได้ที่นี่ สิ่งที่บอกสายที่ต่ออยู่ของเซอร์โวว่ากำหนดพินอะไร อีกอันคือรหัสที่ระบุค่าพินระหว่าง 0 ถึง 180 สำหรับกำหนดมุมการหมุนของเซอร์โว

สรุป

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

หวังว่าข้อมูลเพิ่มเติมอาจได้รับการอัปเดตเป็นครั้งคราวที่นี่ทุกเมื่อที่มี

ในระหว่างนี้ขอให้สนุกกับหลักสูตรการเขียนโปรแกรม Happy Arduinoing กับคุณ !!

คู่ของ: วงจรมิเตอร์ตรวจจับแอลกอฮอล์โดยใช้โมดูลเซ็นเซอร์ MQ-3 ถัดไป: วงจรป้อนสุนัขที่ควบคุมด้วยโทรศัพท์มือถือ