Arduino เป็นบอร์ดไมโครคอนโทรลเลอร์ที่คุณสามารถตั้งโปรแกรมให้ควบคุมอุปกรณ์ภายนอกได้ มันโต้ตอบกับโลกภายนอกผ่านเซ็นเซอร์มอเตอร์ไฟ LED ลำโพง ... และแม้กระทั่งอินเทอร์เน็ตทำให้เป็นแพลตฟอร์มที่ยืดหยุ่นสำหรับโครงการต่างๆ มีไมโครคอนโทรลเลอร์เพียงไม่กี่ตัว แต่ Arduino นั้นได้รับความนิยมเนื่องจากความจริงที่ว่าโครงงานต่างๆนั้นมีการจัดวางและพูดคุยกันบนอินเทอร์เน็ตเป็นอย่างมาก หากคุณค้นหาใน google หรือ youtube คุณจะพบแนวคิดและข้อมูลนับล้านเพื่อเริ่มสำรวจ Arduino ด้วยตัวคุณเอง
แม้ว่าคุณจะไม่มีประสบการณ์การเขียนโปรแกรมไมโครคอนโทรลเลอร์ - ด้วย Arduino คุณจะได้เรียนรู้และเรียนรู้บางสิ่งได้อย่างรวดเร็ว อิเล็กทรอนิกส์ ใช้การทดลอง
คุณต้องเริ่มต้นอะไร
Arduino Uno- 1pc
สาย USB-1pcs
จัมเปอร์ 1pc
1 ชิ้นคณะกรรมการพัฒนา
LED สีแดง 4 ชิ้น
ตัวต้านทาน 220 โอห์ม 4 ชิ้น
ตัวต้านทาน 10 ห้อง 1 ชิ้น
ปุ่มโดยไม่ต้องแก้ไข
มิเตอร์
ไฟ LED RGB พร้อมแคโทดทั่วไป
ทั้งหมดนี้สามารถหาซื้อได้ที่ร้านขายวิทยุท้องถิ่นหรือสั่งซื้อทางอินเทอร์เน็ต
ระบบจำลองออนไลน์ถูกใช้เพื่อสาธิตและจำลองวงจรไฟฟ้า
ตัวจำลองนี้ทำงานได้ดีที่สุดในเบราว์เซอร์ Chrome
ลองดูที่ Arduino อย่างใกล้ชิด
Arduino ไม่ใช่คอมพิวเตอร์ขนาดใหญ่ที่สามารถเชื่อมต่อวงจรภายนอก Arduino Uno ใช้ Atmega 328P
นี่เป็นชิปที่ใหญ่ที่สุดบนกระดาน ชิปนี้รันโปรแกรมที่เก็บไว้ในหน่วยความจำ คุณสามารถดาวน์โหลดโปรแกรมผ่าน usb โดยใช้ Arduino IDE พอร์ต usb ยังให้พลังงานแก่ Arduino
มีขั้วต่อไฟแยกต่างหาก มีเอาต์พุตสองตัวบนบอร์ดที่มีข้อความ 5v และ 3.3v ซึ่งจำเป็นสำหรับการจ่ายไฟให้กับอุปกรณ์ต่าง ๆ คุณจะพบพินที่ระบุว่าเป็น GND ซึ่งเป็นสายดิน (กราวด์คือ 0V) แพลตฟอร์ม Arduino ยังมี 14 เอาต์พุตดิจิตอล (พิน) ทำเครื่องหมายด้วยตัวเลขตั้งแต่ 0 ถึง 13 ซึ่งเชื่อมต่อกับโหนดภายนอกและมีสองสถานะสูงหรือต่ำ (เปิดหรือปิด) ที่อยู่ติดต่อเหล่านี้สามารถทำงานเป็นเอาต์พุตหรือเป็นอินพุตได้เช่น พวกเขาสามารถส่งข้อมูลบางอย่างและควบคุมอุปกรณ์ภายนอกหรือรับข้อมูลจากอุปกรณ์ ข้อสรุปต่อไปนี้บนกระดานได้รับการกำหนด A0-A5 นี่เป็นอินพุตแบบอะนาล็อกที่สามารถรับข้อมูลจากเซ็นเซอร์ต่างๆ สิ่งนี้จะสะดวกเป็นพิเศษเมื่อคุณต้องการวัดช่วงเช่นอุณหภูมิ อินพุตแบบอะนาล็อกมีฟังก์ชั่นเพิ่มเติมที่สามารถเปิดใช้งานแยกกันได้
วิธีใช้เขียงหั่นขนม
ต้องการเขียงหั่นขนมเพื่อเชื่อมต่อชิ้นส่วนชั่วคราวเพื่อตรวจสอบการทำงานของอุปกรณ์ก่อนที่จะประสานทุกอย่างเข้าด้วยกัน
ตัวอย่างต่อไปนี้ทั้งหมดจะถูกรวบรวมไว้บนเขียงหั่นขนมเพื่อให้คุณสามารถเปลี่ยนแปลงวงจรได้อย่างรวดเร็วและนำชิ้นส่วนกลับมาใช้ซ้ำโดยไม่รบกวนการบัดกรี
เขียงหั่นขนมมีแถวของรูที่คุณสามารถใส่ชิ้นส่วนและสายไฟ บางส่วนของหลุมเหล่านี้เชื่อมต่อกันด้วยไฟฟ้า
แถวบนและแถวล่างทั้งสองนั้นเชื่อมต่อกันเป็นชุดตลอดทั้งกระดาน แถวเหล่านี้ใช้เพื่อให้พลังงานแก่วงจร มันอาจเป็น 5v หรือ 3.3v แต่ในกรณีใด ๆ สิ่งแรกที่คุณต้องทำคือเชื่อมต่อ 5v และ GND เข้ากับเขียงหั่นขนมตามที่แสดงในรูป บางครั้งการเชื่อมต่อแถวเหล่านี้อาจถูกขัดจังหวะในช่วงกลางของบอร์ดจากนั้นถ้าคุณต้องการคุณสามารถเชื่อมต่อพวกเขาดังแสดงในรูป
รูที่เหลืออยู่ที่อยู่ตรงกลางของบอร์ดจะถูกแบ่งออกเป็นห้ารู พวกเขาจะใช้ในการเชื่อมต่อชิ้นส่วนวงจร
สิ่งแรกที่เราเชื่อมต่อกับไมโครคอนโทรลเลอร์คือ LED แผนภาพการเชื่อมต่อไฟฟ้าปรากฏขึ้นในภาพ
ตัวต้านทานในวงจรคืออะไร ในกรณีนี้จะ จำกัด กระแสที่ผ่าน LED LED แต่ละตัวได้รับการออกแบบมาสำหรับกระแสไฟเฉพาะและหากกระแสนี้มีค่ามากกว่า LED จะล้มเหลว ค้นหาว่าตัวต้านทานควรใช้ค่ากฎของโอห์มเท่าไร สำหรับผู้ที่ไม่ทราบหรือลืมกฎของโอห์มกล่าวว่ามีการพึ่งพากระแสเชิงเส้นของแรงดันไฟฟ้า นั่นคือยิ่งเราใช้แรงดันไฟฟ้ากับตัวต้านทานมากเท่าไรกระแสก็จะไหลผ่านตัวต้านทานมากขึ้นเท่านั้น
V = I * R
ที่ไหน V- แรงดันไฟฟ้าข้ามตัวต้านทาน
ผม- กระแสไฟฟ้าผ่านตัวต้านทาน
R- ความต้านทานที่จะพบ
ก่อนอื่นเราต้องหาค่าแรงดันข้ามตัวต้านทาน LED 3 มม. หรือ 5 มม. ส่วนใหญ่ที่คุณจะใช้มีแรงดันไฟฟ้า 3V ดังนั้นบนตัวต้านทานเราจำเป็นต้องจ่าย 5-3 = 2v
จากนั้นเราคำนวณกระแสที่ผ่านตัวต้านทาน
ไฟ LED ส่วนใหญ่ 3 และ 5 มม. จะเรืองแสงที่ความสว่างเต็มที่ที่ปัจจุบัน 20mA กระแสไฟฟ้าที่มากกว่านี้สามารถปิดการใช้งานได้และกระแสไฟฟ้าที่น้อยกว่าจะลดความสว่างโดยไม่ก่อให้เกิดอันตรายใด ๆ
ดังนั้นเราต้องการเปิด LED ในวงจร 5v เพื่อให้มีกระแส 20mA เนื่องจากชิ้นส่วนทั้งหมดรวมอยู่ในหนึ่งวงจรตัวต้านทานจะมีกระแส 20 mA
เราได้รับ
2V = 20 mA * R
2V = 0.02A * R
R = 100 โอห์ม
100 โอห์มเป็นความต้านทานขั้นต่ำสุดจะดีกว่าหากใช้น้อยกว่าเพราะ LED มีความแตกต่างในลักษณะบางอย่าง
ในตัวอย่างนี้ใช้ตัวต้านทาน 220 โอห์ม เพียงเพราะผู้เขียนมีจำนวนมาก: ขยิบตา:
ใส่ LED เข้าไปในรูตรงกลางบอร์ดเพื่อให้ขั้วต่อยาวนั้นต่อกับขั้วใดตัวหนึ่งของตัวต้านทาน เชื่อมต่อปลายที่สองของตัวต้านทานกับ 5V และเชื่อมต่อเอาท์พุทที่สองของ LED กับ GND ไฟ LED ควรสว่างขึ้น
โปรดทราบว่ามีความแตกต่างในวิธีการเชื่อมต่อ LED กระแสไหลจากเทอร์มินัลที่ยาวกว่าไปยังอันที่สั้นกว่า ในแผนภาพสามารถจินตนาการได้ว่ากระแสไฟฟ้าไหลในทิศทางที่เป็นรูปสามเหลี่ยมกำกับ ลองพลิก LED แล้วคุณจะเห็นว่ามันไม่สว่างขึ้น
แต่วิธีที่คุณเชื่อมต่อตัวต้านทานไม่มีความแตกต่างเลย คุณสามารถพลิกกลับหรือลองเชื่อมต่อกับเอาท์พุทอื่น ๆ ของ LED ซึ่งจะไม่ส่งผลกระทบต่อการทำงานของวงจร มันจะยังคง จำกัด กระแสผ่าน LED
กายวิภาคของ Arduino Sketch
โปรแกรมสำหรับ Arduino เรียกว่าร่าง ประกอบด้วยฟังก์ชั่นหลักสองอย่าง ฟังก์ชัน การติดตั้ง และฟังก์ชั่น ห่วง
ภายในฟังก์ชั่นนี้คุณจะตั้งค่าพื้นฐานทั้งหมด ข้อสรุปว่าจะทำงานกับอินพุตหรือเอาต์พุตซึ่งไลบรารีที่จะเชื่อมต่อจะเริ่มต้นตัวแปร ฟังก์ชัน ตั้งค่า () มันเริ่มต้นเพียงครั้งเดียวระหว่างร่างภาพเมื่อโปรแกรมเริ่มทำงาน
นี่คือฟังก์ชั่นหลักที่ดำเนินการหลังจากนั้น ตั้งค่า (). อันที่จริงนี่คือโปรแกรมเอง ฟังก์ชั่นนี้จะทำงานอย่างไม่มีกำหนดจนกว่าคุณจะปิดเครื่อง
Arduino กระพริบ LED
ในตัวอย่างนี้เราจะเชื่อมต่อวงจรกับ LED กับหนึ่งในหมุดดิจิตอล Arduino และเราจะเปิดและปิดโดยใช้โปรแกรมและคุณจะได้เรียนรู้ฟังก์ชั่นที่มีประโยชน์มากมาย
- ฟังก์ชั่นนี้ใช้ ตั้งค่า () บางส่วนของโปรแกรมและทำหน้าที่เริ่มต้นข้อสรุปที่คุณจะใช้เป็นอินพุต (INPUT) หรือออกจาก (ขาออก). คุณไม่สามารถอ่านหรือเขียนข้อมูลจากหมุดจนกว่าคุณจะตั้งค่าตาม pinMode. ฟังก์ชั่นนี้มีสองข้อโต้แย้ง: pinNumber- นี่คือหมายเลขพินที่คุณจะใช้
โหมด- กำหนดวิธีการทำงานของพิน ตรงทางเข้า (INPUT) หรือออกจาก (ขาออก). เพื่อให้แสงสว่าง LED เราจะต้องให้สัญญาณ จาก Arduino ในการทำเช่นนี้เรากำหนดค่าหมุดให้ออก
- ฟังก์ชั่นนี้ทำหน้าที่ในการตั้งค่าสถานะ (รัฐ) หมุด (PinNumber). มีสองสถานะหลัก (โดยทั่วไปมี 3) หนึ่งคือ HIGHพินจะเป็น 5v และอีกอันคือ ต่ำ และพินจะเป็น 0v ดังนั้นเพื่อให้ไฟ LED สว่างขึ้นเราจำเป็นต้องตั้งค่าระดับสูงบนพินที่เชื่อมต่อกับ LED HIGH.
- ล่าช้า ทำหน้าที่ชะลอโปรแกรมสำหรับช่วงเวลาที่ระบุในหน่วยมิลลิวินาที
ด้านล่างเป็นรหัสที่ทำให้ LED กะพริบ
// LED กะพริบตา
int ledPin = 7; // Arduino ขาที่เชื่อมต่อ LED
การตั้งค่าเป็นโมฆะ () {
pinMode (ledPin, OUTPUT); // ตั้งพินเป็น EXIT
}
void loop () {
digitalWrite (ledPin, HIGH); // เปิดไฟ LED
หน่วงเวลา (1000); // ล่าช้า 1000 ms (1 วินาที)
digitalWrite (ledPin, LOW); // ปิด LED
ล่าช้า (1,000); // รอ 1 วินาที
}
คำอธิบายเล็กน้อยเกี่ยวกับรหัส
บรรทัดที่ขึ้นต้นด้วย "//" คือความคิดเห็นโดย Arduino ที่ไม่สนใจ
คำสั่งทั้งหมดลงท้ายด้วยเครื่องหมายอัฒภาคหากคุณลืมคุณจะได้รับข้อความแสดงข้อผิดพลาด
ledPinเป็นตัวแปร ตัวแปรถูกใช้ในโปรแกรมเพื่อเก็บค่า ในตัวอย่างนี้ตัวแปร ledPin กำหนดค่าเป็น 7 นี่คือหมายเลขพินของ Arduino เมื่อ Arduino ในโปรแกรมพบสายอักขระที่มีตัวแปร ledPin มันจะใช้ค่าที่เราระบุไว้ก่อนหน้านี้
ดังนั้นบันทึก pinMode (ledPin, OUTPUT) คล้ายกับบันทึก pinMode (7, OUTPUT).
แต่ในกรณีแรกมันเพียงพอสำหรับคุณที่จะเปลี่ยนตัวแปรและมันจะเปลี่ยนในแต่ละบรรทัดที่มันถูกใช้และในกรณีที่สองในการเปลี่ยนตัวแปรคุณต้องทำการเปลี่ยนแปลงในปากกาในแต่ละคำสั่ง
ในบรรทัดแรกระบุประเภทของตัวแปร เมื่อตั้งโปรแกรม Arduino มันเป็นสิ่งสำคัญที่จะต้องประกาศประเภทของตัวแปร สำหรับตอนนี้มันเพียงพอแล้วที่คุณจะรู้ INT ประกาศตัวเลขที่เป็นลบและบวก
ด้านล่างนี้มีการนำเสนอ การสร้างแบบจำลอง ร่าง กดเริ่มเพื่อดูการทำงานของวงจร
ตามที่คาดไว้ไฟ LED จะดับและสว่างขึ้นหลังจากผ่านไปหนึ่งวินาที ลองเปลี่ยนความล่าช้าเพื่อดูว่ามันทำงานอย่างไร
การจัดการไฟ LED หลายดวง
ในตัวอย่างนี้คุณจะได้เรียนรู้วิธีการควบคุมไฟ LED หลายดวง ในการทำเช่นนี้ให้ติดตั้ง LED อีก 3 ตัวบนบอร์ดและเชื่อมต่อกับตัวต้านทานและหมุด Arduino ดังที่แสดงด้านล่าง
ในการเปิดและปิดไฟ LED คุณจะต้องเขียนโปรแกรมดังนี้:
// Multi LED Blink
int led1Pin = 4;
int led2Pin = 5;
int led3Pin = 6;
int led4Pin = 7;
การตั้งค่าเป็นโมฆะ () {
// ตั้งพินเป็น EXIT
pinMode (led1Pin, OUTPUT);
pinMode (led2Pin, OUTPUT);
pinMode (led3Pin, OUTPUT);
pinMode (led4Pin, OUTPUT);
}
void loop () {
digitalWrite (led1Pin, HIGH); // เปิดไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
digitalWrite (led1Pin, LOW); // ดับไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
// ทำเช่นเดียวกันสำหรับ LED 3 ดวงอื่น
digitalWrite (led2Pin, HIGH); // เปิดไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
digitalWrite (led2Pin, LOW); // ดับไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
digitalWrite (led3Pin, HIGH); // เปิดไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
digitalWrite (led3Pin, LOW); // ดับไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
digitalWrite (led4Pin, HIGH); // เปิดไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
digitalWrite (led4Pin, LOW); // ดับไฟ LED
ล่าช้า (1,000); // ล่าช้า 1 วินาที
}
โปรแกรมนี้จะทำงานได้ดี แต่นี่ไม่ใช่ทางออกที่สมเหตุสมผลที่สุด รหัสจะต้องมีการเปลี่ยนแปลง เพื่อให้โปรแกรมทำงานซ้ำแล้วซ้ำอีกเราจะใช้โครงสร้างที่เรียกว่า
รอบจะสะดวกเมื่อคุณจำเป็นต้องทำซ้ำการกระทำเดียวกันหลายครั้ง ในรหัสข้างต้นเราทำซ้ำบรรทัด
digitalWrite (led4Pin, สูง);
ล่าช้า (1,000);
digitalWrite (led4Pin, LOW);
ล่าช้า (1,000);
รหัสร่างเต็มในสิ่งที่แนบมา
การปรับความสว่าง LED
บางครั้งคุณจะต้องเปลี่ยนความสว่างของไฟ LED ในโปรแกรม สิ่งนี้สามารถทำได้โดยใช้คำสั่ง analogWrite (). คำสั่งนี้เปิดและปิดไฟ LED อย่างรวดเร็วจนมองไม่เห็นการสั่นไหวนี้ หากไฟ LED เปิดครึ่งเวลาและปิดไปครึ่งหนึ่งจะปรากฏว่ามีแสงสว่างที่ความสว่างครึ่งหนึ่ง สิ่งนี้เรียกว่าการปรับความกว้างพัลส์ (PWM หรือ PWM เป็นภาษาอังกฤษ) PWM ใช้ค่อนข้างบ่อยเนื่องจากสามารถใช้เพื่อควบคุมส่วนประกอบ "อะนาล็อก" โดยใช้รหัสดิจิทัล ไม่ใช่ขา Arduino ทั้งหมดที่เหมาะสำหรับวัตถุประสงค์เหล่านี้ เฉพาะข้อสรุปที่มีการกำหนดเช่นนี้ "~"คุณจะเห็นมันติดกับหมุด 3,5,6,9,10,11
เชื่อมต่อหนึ่งใน LEDs ของคุณกับหนึ่งในสัญญาณ PWM (สำหรับผู้เขียนนี่คือพิน 9) ตอนนี้เรียกใช้ร่าง LED กระพริบร่าง แต่แรกเปลี่ยนคำสั่ง digitalWrite () บน analogWrite (). analogWrite () มันมีสองข้อโต้แย้ง: ครั้งแรกคือหมายเลขพินและที่สองคือค่า PWM (0-255) ตามที่ใช้กับไฟ LED นี้จะเป็นความสว่างของพวกเขาและสำหรับมอเตอร์ไฟฟ้าความเร็วในการหมุน ด้านล่างเป็นรหัสตัวอย่างสำหรับความสว่างของ LED ที่แตกต่างกัน
// เปลี่ยนความสว่างของ LED
int ledPin = 9; // LED เชื่อมต่อกับพินนี้
การตั้งค่าเป็นโมฆะ () {
pinMode (ledPin, OUTPUT); // เริ่มต้นพินเพื่อส่งออก
}
void loop () {
analogWrite (ledPin, 255); // ความสว่างเต็ม (255/255 = 1)
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
digitalWrite (ledPin, LOW); // ปิด LED
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
analogWrite (ledPin, 191); // ความสว่างที่ 3/4 (191/255 ~ = 0.75)
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
digitalWrite (ledPin, LOW); // ปิด LED
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
analogWrite (ledPin, 127); // ความสว่างครึ่งหนึ่ง (127/255 ~ = 0.5)
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
digitalWrite (ledPin, LOW); // ปิด LED
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
analogWrite (ledPin, 63); // ความสว่างของไตรมาส (63/255 ~ = 0.25)
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
digitalWrite (ledPin, LOW); // ปิด LED
ดีเลย์ (1,000); // หยุดชั่วคราว 1 วินาที
}
ลองเปลี่ยนค่า PWM ในคำสั่ง analogWrite ()เพื่อดูว่ามันมีผลต่อความสว่างอย่างไร
ถัดไปคุณจะได้เรียนรู้วิธีการปรับความสว่างได้อย่างราบรื่นจากเต็มรูปแบบเป็นศูนย์ แน่นอนคุณสามารถคัดลอกรหัส 255 ครั้ง
analogWrite (ledPin, ความสว่าง);
ล่าช้า (5); // ล่าช้าสั้น
ความสว่าง = ความสว่าง + 1;
แต่คุณเข้าใจ - มันจะไม่เป็นประโยชน์ สำหรับสิ่งนี้เป็นการดีที่สุดที่จะใช้ FOR วนที่เคยใช้มาก่อน
ตัวอย่างต่อไปนี้ใช้สองรอบวงจรหนึ่งเพื่อลดความสว่างจาก 255 เป็น 0
สำหรับ (ความสว่างภายใน = 0; ความสว่าง = 0; ความสว่าง -) {
analogWrite (ledPin, ความสว่าง);
ล่าช้า (5);
}
ล่าช้า (5) ใช้เพื่อลดอัตราการเพิ่มขึ้นและลดลงของความสว่าง 5 * 256 = 1280 ms = 1.28 วินาที)
บรรทัดแรกใช้ "Brightness-"เพื่อให้ค่าความสว่างลดลง 1 ทุกครั้งที่มีรอบเกิดซ้ำโปรดทราบว่ารอบจะทำงานได้ตราบใดที่ ความสว่าง> = 0. การเปลี่ยนป้าย > บนป้าย >= เรารวม 0 ในช่วงความสว่าง ร่างนี้เป็นแบบจำลองด้านล่าง
// เปลี่ยนความสว่างได้อย่างราบรื่น
int ledPin = 9; // LED เชื่อมต่อกับพินนี้
การตั้งค่าเป็นโมฆะ () {
pinMode (ledPin, OUTPUT); // เริ่มต้น pin เพื่อออก
}
void loop () {
// ค่อยๆเพิ่มความสว่าง (0 ถึง 255)
สำหรับ (ความสว่างภายใน = 0; ความสว่าง = 0; ความสว่าง -) {
analogWrite (ledPin, ความสว่าง);
ล่าช้า (5);
}
ล่าช้า (1,000); // รอ 1 วินาที
// ลดความสว่างได้อย่างราบรื่น (255 ถึง 0)
สำหรับ (ความสว่างภายใน = 255; ความสว่าง> = 0; ความสว่าง -) {
analogWrite (ledPin, ความสว่าง);
ล่าช้า (5);
}
ล่าช้า (1,000); // รอ 1 วินาที
}
}
สิ่งนี้ไม่สามารถมองเห็นได้ แต่ความคิดนั้นชัดเจน
RGB LED และ Arduino
จริง ๆ แล้วไฟ LED RGB เป็น LED สามสีที่แตกต่างกันในที่อยู่อาศัยเดียว
การรวม LED ที่แตกต่างกันด้วยความสว่างที่แตกต่างกันคุณสามารถรวมและรับสีที่แตกต่างกัน สำหรับ Arduino ที่จำนวนการไล่สีของความสว่างเป็น 256 คุณจะได้รับ 256 ^ 3 = 16581375 สีที่เป็นไปได้ ในความเป็นจริงแน่นอนว่าจะมีน้อยกว่า
LED ที่เราจะใช้เป็นแคโทดทั่วไป กล่าวคือ ไฟ LED ทั้งสามดวงเชื่อมต่อแบบโครงสร้างโดยแคโทดไปยังขั้วหนึ่ง เราจะเชื่อมต่อพินนี้กับพิน GND เทอร์มินัลที่เหลือผ่านตัวต้านทาน จำกัด จะต้องเชื่อมต่อกับขั้ว PWM ผู้เขียนใช้ข้อสรุป 9-11 ดังนั้นจึงเป็นไปได้ที่จะควบคุมแต่ละ LED แยกกัน ภาพร่างแรกแสดงวิธีการเปิดแต่ละ LED แยกกัน
// LED RGB - การทดสอบ
// การเชื่อมต่อขา
int red = 9;
int green = 10;
int blue = 11;
การตั้งค่าเป็นโมฆะ () {
pinMode (สีแดง, OUTPUT);
pinMode (สีน้ำเงิน, OUTPUT);
pinMode (สีเขียว, OUTPUT);
}
void loop () {
// เปิด / ปิดไฟ LED สีแดง
digitalWrite (แดง, สูง);
ล่าช้า (500);
digitalWrite (แดง, ต่ำ);
ล่าช้า (500);
// เปิด / ปิดไฟ LED สีเขียว
digitalWrite (สีเขียวสูง);
ล่าช้า (500);
digitalWrite (เขียว, ต่ำ);
ล่าช้า (500);
// เปิด / ปิดไฟ LED สีน้ำเงิน
digitalWrite (สีน้ำเงินสูง);
ล่าช้า (500);
digitalWrite (สีน้ำเงิน, ต่ำ);
ล่าช้า (500);
}
ตัวอย่างต่อไปนี้ใช้คำสั่ง analogWrite () และเพื่อรับค่าความสว่างแบบสุ่มต่างๆสำหรับ LED คุณจะเห็นสีที่เปลี่ยนแปลงแบบสุ่ม
// RGB LED - สีแบบสุ่ม
// การเชื่อมต่อขา
int red = 9;
int green = 10;
int blue = 11;
การตั้งค่าเป็นโมฆะ () {
pinMode (สีแดง, OUTPUT);
pinMode (สีน้ำเงิน, OUTPUT);
pinMode (สีเขียว, OUTPUT);
}
void loop () {
// เลือกสีแบบสุ่ม
analogWrite (แดง, สุ่ม (256));
analogWrite (สีน้ำเงินสุ่ม (256));
analogWrite (สีเขียวสุ่ม (256));
หน่วงเวลา (1,000); // รอหนึ่งวินาที
}
สุ่ม (256)- ส่งกลับตัวเลขสุ่มในช่วงตั้งแต่ 0 ถึง 255
มีร่างในไฟล์ที่แนบซึ่งจะแสดงให้เห็นถึงการเปลี่ยนสีอย่างราบรื่นจากสีแดงเป็นสีเขียวจากนั้นเป็นสีฟ้าสีแดงสีเขียวและอื่น ๆ
ตัวอย่างร่างทำงานได้ แต่มีรหัสซ้ำจำนวนมาก คุณสามารถทำให้รหัสง่ายขึ้นโดยการเขียนฟังก์ชันตัวช่วยของคุณเองซึ่งจะเปลี่ยนสีหนึ่งเป็นสีอื่นอย่างราบรื่น
นี่คือลักษณะ:
ลองดูความหมายของฟังก์ชันในส่วนต่างๆ ฟังก์ชั่นที่เรียกว่า เฟดเดอร์ และมีสองข้อโต้แย้ง แต่ละอาร์กิวเมนต์จะถูกคั่นด้วยเครื่องหมายจุลภาคและมีประเภทที่ประกาศในบรรทัดแรกของคำนิยามฟังก์ชัน: โมฆะเฟดเดอร์ (int color1, int color2). คุณเห็นว่าทั้งสองข้อโต้แย้งนั้นได้รับการประกาศให้เป็น intและพวกเขาจะได้รับชื่อ COLOR1 และ color2 เป็นตัวแปรเงื่อนไขสำหรับกำหนดฟังก์ชัน เป็นโมฆะ หมายความว่าฟังก์ชั่นไม่ได้คืนค่าใด ๆ แต่ก็ดำเนินการคำสั่ง หากจำเป็นต้องเขียนฟังก์ชันที่ส่งคืนผลลัพธ์ของการคูณมันจะเป็นดังนี้:
ตัวคูณ int (int number1, int number2) {
int สินค้า = number1 * number2;
คืนสินค้า
}
แจ้งให้ทราบว่าเราประกาศประเภท int เป็นชนิดส่งคืนแทน
เป็นโมฆะ.
ภายในฟังก์ชั่นมีคำสั่งที่คุณใช้ไปแล้วในร่างก่อนหน้านี้มีเพียงหมายเลขพินเท่านั้นที่ถูกแทนที่ด้วย COLOR1 และ color2. ฟังก์ชั่นที่เรียกว่า เฟดเดอร์อาร์กิวเมนต์จะถูกคำนวณเป็น color1 = สีแดง และ color2 = สีเขียว. ร่างแบบเต็มเก็บถาวรโดยใช้ฟังก์ชั่น
ปุ่ม
ในภาพร่างถัดไปปุ่มที่มีรายชื่อที่เปิดตามปกติจะถูกนำมาใช้โดยไม่ต้องแก้ไข
ซึ่งหมายความว่าแม้ว่าจะไม่ได้กดปุ่ม แต่กระแสไฟไม่ไหลผ่านและหลังจากปล่อยปุ่มจะกลับสู่ตำแหน่งเดิม
ในวงจรนอกเหนือจากปุ่มแล้วจะใช้ตัวต้านทาน ในกรณีนี้มันไม่ได้ จำกัด กระแส แต่ "ดึง" ปุ่มเป็น 0v (GND) กล่าวคือ จนกว่าปุ่มจะกดที่ขาของ Arduino ซึ่งเชื่อมต่ออยู่ระดับจะต่ำ ตัวต้านทานที่ใช้ในวงจร 10 kΩ
// กำหนดปุ่มคลิก
int buttonPin = 7;
การตั้งค่าเป็นโมฆะ () {
pinMode (buttonPin, INPUT); // เริ่มต้นการป้อนพิน
Serial.begin (9600); // เริ่มต้นพอร์ตอนุกรม
}
void loop () {
if (digitalRead (buttonPin) == HIGH) {// หากกดปุ่ม
Serial.println ("กด"); // พิมพ์ "กด"
} อื่น {
Serial.println ("unpressed"); // มิฉะนั้น "unpressed"
}
}
มีทีมใหม่หลายทีมในร่างนี้
- คำสั่งนี้ใช้ค่าสูง (ระดับสูง) และต่ำ (ระดับต่ำ) ของเอาต์พุตที่เรากำลังตรวจสอบ ก่อนหน้านี้ในการตั้งค่า () เอาต์พุตนี้ต้องถูกกำหนดค่าสำหรับอินพุต
; // โดยที่ buttonPin เป็นหมายเลขพินที่เชื่อมต่อปุ่ม
พอร์ตอนุกรมช่วยให้คุณสามารถส่งข้อความ Arduino ไปยังคอมพิวเตอร์ในขณะที่ตัวควบคุมเรียกใช้โปรแกรม สิ่งนี้มีประโยชน์สำหรับการดีบักโปรแกรมส่งข้อความไปยังอุปกรณ์หรือแอพพลิเคชั่นอื่น ๆ ในการเปิดใช้งานการถ่ายโอนข้อมูลผ่านพอร์ตอนุกรม (หรือที่เรียกว่า UART หรือ USART) คุณจะต้องเริ่มต้นการตั้งค่า ()
Serial.begin () มีเพียงหนึ่งอาร์กิวเมนต์คืออัตราการถ่ายโอนข้อมูลระหว่าง Arduino และคอมพิวเตอร์
ร่างคำสั่งที่ใช้ในการแสดงข้อความบนหน้าจอใน Arduino IDE (เครื่องมือ >> การตรวจสอบแบบอนุกรม)
- การออกแบบช่วยให้คุณควบคุมความคืบหน้าของโปรแกรมโดยการรวมเช็คหลาย ๆ อันไว้ในที่เดียว
หาก (ถ้า) digitalRead ส่งกลับค่า HIGH คำว่า "pressed" จะปรากฏขึ้นบนจอภาพ อื่น (มิฉะนั้น) คำว่า "บีบ" จะปรากฏบนจอภาพ ตอนนี้คุณสามารถลองเปิดและปิด LED ด้วยการกดปุ่มเพียงปุ่มเดียว
// การตรวจจับการกดปุ่มพร้อมเอาต์พุต LED
int buttonPin = 7;
int ledPin = 8;
การตั้งค่าเป็นโมฆะ () {
pinMode (buttonPin, INPUT); // คราวนี้เราจะตั้งค่าปุ่ม pin เป็น INPUT
pinMode (ledPin, OUTPUT);
Serial.begin (9600);
}
void loop () {
if (digitalRead (buttonPin) == สูง) {
digitalWrite (ledPin, HIGH);
Serial.println ("กด");
} อื่น {
digitalWrite (ledPin, LOW);
Serial.println ("unpressed");
}
}
อินพุตแบบอะนาล็อก
analogRead ช่วยให้คุณอ่านข้อมูลจากหนึ่งในหมุดอะนาล็อกของ Arduino และแสดงค่าในช่วงตั้งแต่ 0 (0V) ถึง 1023 (5V) หากแรงดันไฟฟ้าที่อินพุตแบบอะนาล็อกคือ 2.5V ดังนั้น 2.5 / 5 * 1023 = 512 จะถูกพิมพ์
analogRead มีเพียงหนึ่งอาร์กิวเมนต์ - นี่คือหมายเลขอินพุตอะนาล็อก (A0-A5) ภาพร่างต่อไปนี้มีรหัสสำหรับอ่านแรงดันไฟฟ้าจากโพเทนชิออมิเตอร์ ในการทำเช่นนี้ให้เชื่อมต่อตัวต้านทานผันแปรพินสุดขีดกับพิน 5V และ GND และพินกลางไปยังอินพุต A0
เรียกใช้รหัสต่อไปนี้และดูในจอภาพอนุกรมว่าค่าเปลี่ยนแปลงอย่างไรขึ้นอยู่กับการหมุนของปุ่มตัวต้านทาน
// อินพุตแบบอะนาล็อก
int potPin = A0; // เอาต์พุตกลางของโพเทนชิออมิเตอร์เชื่อมต่อกับพินนี้
การตั้งค่าเป็นโมฆะ () {
// แอนะล็อกพินถูกเปิดใช้งานโดยอินพุตโดยค่าเริ่มต้นดังนั้นไม่จำเป็นต้องเริ่มต้น
Serial.begin (9600);
}
void loop () {
int potVal = analogRead (potPin); // potVal เป็นตัวเลขระหว่าง 0 ถึง 1,023
Serial.println (potVal);
}
ร่างต่อไปรวมร่างคลิกปุ่มและร่างควบคุมความสว่าง LED LED จะเปิดจากปุ่มและโพเทนชิออมิเตอร์จะควบคุมความสว่างของแสง
การตรวจจับการกดปุ่ม // พร้อมเอาต์พุต LED และความเข้มของตัวแปร
int buttonPin = 7;
int ledPin = 9;
int potPin = A0;
การตั้งค่าเป็นโมฆะ () {
pinMode (buttonPin, INPUT);
pinMode (ledPin, OUTPUT);
Serial.begin (9600);
}
void loop () {
if (digitalRead (buttonPin) == HIGH) {// หากกดปุ่มแล้ว
int analogVal = analogRead (potPin);
int scaledVal = แผนที่ (analogVal, 0, 1023, 0, 255);
analogWrite (ledPin, scaledVal); // เปิดไฟ led โดยตั้งค่าความเข้มโดย pot
Serial.println ("กด");
} อื่น {
digitalWrite (ledPin, LOW); // ปิดหากไม่ได้กดปุ่ม
Serial.println ("unpressed");
}
}