สัญญาณไฟจราจรบน Arduino สัญญาณไฟจราจรบน Arduino

ในบทเรียนนี้ เราจะทำสิ่งที่ง่ายที่สุด ไฟจราจร LED สามดวง. มันควรจะทำงานเช่นนี้

1. แสงสีแดงเท่านั้นที่ส่องแสงสัญญาณไฟจราจรในอนาคตของเรา

2. เปิดไฟสีเหลืองโดยไม่ต้องปิดไฟจราจรสีแดง.

3. ปิด สีแดงและสีเหลืองเปลี่ยนเป็นสีเขียว

4. ปิดไฟจราจรสีเขียว เปิดไฟสีเหลือง

จากนั้นวนซ้ำจากสัญญาณไฟจราจรสีแดง

สำหรับบทเรียนเราต้องการ:

เชื่อมต่อ LED สามดวงเข้ากับบอร์ด Arduino UNO. เราจะได้รูปแบบดังกล่าว

แผนภาพ.

ร่างมีลักษณะเช่นนี้

int led_red = 2; // ขาเชื่อมต่อ 2 int led_yellow = 3; // ขาเชื่อมต่อ 3 int led_green = 4; // พินการเชื่อมต่อ 4 การตั้งค่าเป็นโมฆะ () ( pinMode (led_red, OUTPUT); pinMode (led_yellow, OUTPUT); pinMode (led_green, OUTPUT); ) void loop () ( digitalWrite ( led_red, HIGH); delay (10000); / / รอ digitalWrite(led_yellow, HIGH); delay(2000); // รอ digitalWrite(led_green, HIGH); digitalWrite(led_red, LOW); digitalWrite(led_yellow, LOW); delay(10000); // รอ digitalWrite (led_yellow, HIGH); digitalWrite(led_green, LOW); delay(2000); // กำลังรอ digitalWrite(led_yellow, LOW); )

ในการควบคุมไฟ LED ให้ใช้ฟังก์ชัน .

ลองแทนที่ฟังก์ชันมาตรฐานด้วยฟังก์ชัน Led() ของเรา

Void Led (พิน uint8_t สถานะไบต์) ( digitalWrite (พิน สถานะ); )

ฟังก์ชันยอมรับพินตัวแปรสองตัว - พินของ LED และสถานะ - สถานะของ LED หรือ

เป็นผลให้เราได้ภาพร่างดังกล่าว

int led_red = 2; // ขาเชื่อมต่อ 2 int led_yellow = 3; // ขาเชื่อมต่อ 3 int led_green = 4; // พินการเชื่อมต่อ 4 การตั้งค่าเป็นโมฆะ () ( pinMode (led_red, OUTPUT); pinMode (led_yellow, OUTPUT); pinMode (led_green, OUTPUT); ) void loop () ( Led (led_red, HIGH); delay (10000); / / รอ Led (led_yellow, สูง); ล่าช้า (2000); // รอ Led (led_green, สูง); Led (led_red, ต่ำ); Led (led_yellow, ต่ำ); หน่วงเวลา (10,000); // รอ Led (led_yellow, HIGH); Led (led_green, LOW); delay(2000); // Wait for Led (led_yellow, LOW); ) void Led (uint8_t pin, สถานะไบต์) ( digitalWrite(pin, status); )

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

แนวคิดที่ว่าคืออะไร ฟังก์ชั่นและวิธีการประกาศจะมีประโยชน์ในบทเรียนถัดไป

หากคุณมีคำถาม ดูวิดีโอที่นั่น ฉันอธิบายรายละเอียดเกี่ยวกับโปรแกรมสัญญาณไฟจราจรบน Arduino

สุขภาพดีจงมีแด่สาวกของ dajeldor ผู้ที่ชื่นชอบโซเซียลลิสต์และผู้ที่เข้ามาสู่แสงสว่าง!)))

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

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

สวัสดี ดัชเจลดอร์ที่รัก!

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

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

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

เนื่องจากเนื้อหาจะมีขนาดใหญ่เกินไปในเวอร์ชันข้อความ ฉันจึงแบ่งงานออกเป็นวิดีโอ ลิงก์ทั้งหมดไปยังโปรแกรม (ภาพร่าง) รายละเอียดที่จำเป็น ฯลฯ อยู่ในคำอธิบายใต้วิดีโอ

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

สัญญาณไฟจราจรสองสีที่เรียบง่าย

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

สัญญาณไฟจราจรสามสีสองดวง

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

สัญญาณไฟจราจรและทางออก

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

ดังที่ฉันได้กล่าวไว้ในวิดีโอแรก - หากต้องการเปลี่ยนสิ่งที่ทรงพลังกว่า LED ขนาดเล็ก เราจำเป็นต้องมีโมดูล/ชิ้นส่วนภายนอก เช่น รีเลย์และทรานซิสเตอร์ เป็นการดีที่สุดที่จะใช้โมดูลรีเลย์ที่ออกแบบมาเพื่อทำงานกับระดับต่างๆ ตัวควบคุมนี้. ในกรณีของ arduino nano และเกือบทั้งสาย นี่คือ 5 โวลต์ โปรแกรมควบคุมของฉันใช้ระดับสูง (เช่น แรงดันไฟฟ้าปรากฏที่เอาต์พุต) ดังนั้นโมดูลจึงต้องใช้กับการควบคุมเชิงบวก แต่แม้ว่าคุณจะมีโมดูลที่ทำงานบน ระดับเชิงลบ(ศูนย์โลจิคัลเอาต์พุตคือมวล / ลบ) ก็ไม่สำคัญเช่นกัน - คุณต้องแก้ไขโปรแกรมเล็กน้อย โมดูลรีเลย์มีจำหน่ายในรุ่นต่างๆ - หนึ่งรีเลย์, สอง, สี่, แปด, สิบ, สิบหก, แม้กระทั่ง 32 รีเลย์ตัวเดียวก็เพียงพอที่จะควบคุมสัญญาณไฟจราจรสองสี ในกรณีของสัญญาณไฟจราจรสามสีจะเป็นการดีกว่าถ้าใช้รีเลย์สามตัวเพื่อให้สามารถใช้การกะพริบได้ แต่คุณสามารถใช้สองสีได้เนื่องจากรีเลย์มีหน้าสัมผัสสามตัว - หน้าสัมผัสกลางหนึ่งหน้าและสองหน้าสัมผัสเอาต์พุตหนึ่งใน ซึ่งปกติจะปิดไปที่ส่วนกลาง ส่วนอีกอันจะเปิดตามปกติ ซึ่งสามารถใช้บันทึกเอาต์พุตของคอนโทรลเลอร์ได้อีกครั้งด้วยการอัปเกรดโปรแกรม

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

ฉันหวังว่าเนื้อหานี้จะเป็นประโยชน์ ทันทีที่มีสิ่งใหม่ปรากฏขึ้น ฉันจะอัปเดตหัวข้อ ขอให้ทุกคนโชคดีในการนำความคิดของตัวเองไปใช้ แม้แต่ความคิดที่บ้าที่สุด (ภายในกฎหมาย =))!

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

สิ่งที่เราต้องการจากวัสดุ:
Pusher (เราจะใช้เป็นพื้นฐานสำหรับการประดิษฐ์ของเรา!)

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

ขั้นตอนที่ 2 การติดตั้ง "กระบังหน้า"
ใช้สว่านเจาะรูสำหรับกระบังหน้าของเรา

ดังนั้น คุณจึงเป็นเจ้าของหนึ่งในตัวสร้าง Arduino ของซีรีส์ “Dare” (“Basic”, “Learning Arduino” และ “Smart Home”) คุณได้เชื่อมต่อบอร์ดและเปิดตัวตัวอย่างแรกใน Arduino IDE แล้ว - “Hello, World” สำหรับ Arduino (ไฟ LED กระพริบ) ดีมาก คุณได้ก้าวแรกในฐานะนักพัฒนาศิลปินที่ใช้ Arduino แล้ว ตอนนี้เราจะพิจารณาโครงการที่ซับซ้อนและมีประโยชน์มากขึ้นด้วยกัน - สร้างสัญญาณไฟจราจรสองดวงโดยใช้ Arduinoสำหรับทางแยกของถนนที่หุ่นยนต์ที่คุณสร้างขึ้นจะสามารถเคลื่อนที่ได้
สำหรับการประกอบ สัญญาณไฟจราจร Arduinoคุณจะต้องใช้ชิ้นส่วนต่อไปนี้ซึ่งรวมอยู่ในชุด Arduino แต่ละชุด:

1. Arduino Uno;
2. สาย USB;
3. กระดานต้นแบบ;
4. สาย "พ่อ - พ่อ" - 7 ชิ้น;
5. ตัวต้านทาน 220 โอห์ม - 6 ชิ้น;
6. ไฟ LED สีแดง - 2 ชิ้น;
7. ไฟ LED สีเขียว - 2 ชิ้น;
8. ไฟ LED สีเหลือง - 2 ชิ้น

LED เป็นอุปกรณ์เซมิคอนดักเตอร์ที่แปลงกระแสไฟฟ้าให้เป็นแสงโดยตรง ลักษณะสีของไฟ LED ขึ้นอยู่กับองค์ประกอบทางเคมีของสารกึ่งตัวนำที่ใช้ LED เปล่งแสงในส่วนที่แคบของสเปกตรัม ในโครงการสัญญาณไฟจราจร Arduino ของเรา เราจะใช้ไฟ LED สามสี (เขียว เหลือง แดง) ที่สอดคล้องกับสัญญาณไฟจราจรสามสี
LED เป็นแบบโพลาไรซ์ ไม่สำคัญว่าคุณจะเชื่อมต่อด้วยวิธีใด ตะกั่วที่เป็นบวกของ LED (ยาวกว่า) เรียกว่าแอโนด ตะกั่วที่เป็นลบเรียกว่าแคโทด เช่นเดียวกับไดโอดทั้งหมด ไฟ LED อนุญาตให้กระแสไหลในทิศทางเดียวเท่านั้น - จากขั้วบวกไปยังขั้วลบ เนื่องจากกระแสไหลจากบวกไปลบ ขั้วบวกของ LED จะต้องเชื่อมต่อกับสัญญาณดิจิตอล 5V และแคโทดต้องเชื่อมต่อกับกราวด์
เราจะเชื่อมต่อ LED ของสัญญาณไฟจราจรดวงแรกเข้ากับหมุดดิจิทัล D7, D8, D9 และ LED ของสัญญาณไฟจราจรดวงที่สองเข้ากับหมุดดิจิทัล D10, D11, D12 ของบอร์ด Arduino LED ควรต่ออนุกรมกับตัวต้านทานที่ทำหน้าที่เป็นตัวจำกัดกระแสเสมอ ยิ่งค่าตัวต้านทานมีค่ามากเท่าใดก็ยิ่งจำกัดกระแสมากขึ้นเท่านั้น ในการทดลองนี้ เราใช้ตัวต้านทาน 220 โอห์ม
เราประกอบวงจรที่แสดงในรูปที่ 1

รูปที่ 1 แผนภาพการเชื่อมต่อ LED

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

#กำหนด TIME_GREEN 10,000 #กำหนด TIME_RED 10,000 #กำหนด TIME_YELLOW 3000 #กำหนด TIME_BLINK 300

มาเพิ่มค่าคงที่และข้อสรุปของการเชื่อมต่อสัญญาณไฟจราจร (ในตัวอย่างนี้ เราพิจารณาสัญญาณไฟจราจรเดียว)

#กำหนด PIN_GREEN1 7 #กำหนด PIN_RED 9 #กำหนด PIN_YELLOW 8

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

// กำหนดค่าพิน Arduino เป็นเอาต์พุต pinMode(PIN_GREEN1, OUTPUT); โหมดพิน (PIN_YELLOW1, เอาต์พุต); โหมดพิน (PIN_RED1, เอาต์พุต); // และปิดไฟ LED ทั้งหมด digitalWrite(PIN_GREEN1, LOW); digitalWrite (PIN_YELLOW1, ต่ำ); digitalWrite (PIN_RED1, ต่ำ);

ในขั้นตอน loop() เรามาเริ่มสัญญาณไฟจราจรกัน ระยะเวลาของไฟ LED สีแดงและสีเขียวและการกะพริบสีเหลืองถูกกำหนดโดยฟังก์ชัน delay()
หากต้องการให้ไฟ LED สีเหลืองกะพริบ เราจะใช้การวนซ้ำเป็นระยะเวลา TIME_YELLOW โดยมีขั้นละ TIME_BLINK ด้วยคำสั่ง blinkyellow= !blinkyellow เราจะเปลี่ยนค่าของตัวแปร blinkyellow เป็นค่าตรงข้ามและเปลี่ยนสถานะของ LED สีเหลือง

สำหรับ (int i=0;i

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

// พิน Arduino สำหรับเชื่อมต่อ LEDs #define PIN_GREEN1 7 #define PIN_YELLOW1 8 #define PIN_RED1 9 // LED เวลาเป็น ms // สีเขียว #define TIME_GREEN 5000 // สีแดง #define TIME_RED 5000 // สีเหลือง #define TIME_YELLOW 3000 // ระยะเวลากระพริบ สีเหลือง #define TIME_BLINK 300 // ตัวแปรกะพริบเพื่อสลับกัน บูลีนสีเหลือง กะพริบสีเหลือง = จริง; การตั้งค่าเป็นโมฆะ () ( // ตั้งค่าพิน Arduino เป็นเอาต์พุต pinMode(PIN_GREEN1, OUTPUT); pinMode(PIN_YELLOW1, OUTPUT); pinMode(PIN_RED1, OUTPUT); // และปิดไฟ LED ทั้งหมด digitalWrite(PIN_GREEN1, LOW); digitalWrite(PIN_YELLOW1 , LOW); digitalWrite(PIN_RED1, LOW); ) // ฟังก์ชันลูปทำงานซ้ำแล้วซ้ำอีกตลอดไป void loop() ( // สีเขียว digitalWrite(PIN_GREEN1, HIGH); หน่วงเวลา (TIME_GREEN); blinkyellow=true; // สีเหลือง - กะพริบเป็นเวลา (int i=0;i

หลังจากโหลดแล้ว เราสังเกตการทำงานของสัญญาณไฟจราจร (ดูรูปที่ 2,3,4) โดยการเปลี่ยนค่าคงที่ TIME_GREEN , TIME_RED , TIME_YELLOW เราจะเปลี่ยนเวลา "การเผาไหม้" ของ LED แต่ละดวง โดยค่าคงที่ TIME_BLINK จะปรับระยะเวลาการกะพริบของ LED สีเหลือง

อาดูรโน่. เริ่ม

ทักทาย! เรากำลังเริ่มต้นหลักสูตรของนักสู้รุ่นเยาว์ของโลก Arduino

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

วิธีการเริ่มต้น

ในการเริ่มหลักสูตร คุณต้อง:

1. ดาวน์โหลดสภาพแวดล้อมการพัฒนา Arduino
2. รับบอร์ด Arduino หรืออะนาล็อกด้วยตัวคุณเอง
3. เรียนรู้วิธีเชื่อมต่อบอร์ดกับคอมพิวเตอร์
4. รับตัวเองปุยบาง รายละเอียดที่จำเป็นทั้งหมดจะอยู่ในคำอธิบาย
5. อย่ากลัวที่จะทำผิดพลาด หากไม่มีข้อผิดพลาดก็จะไม่มีการพัฒนา
6. มีความปรารถนาที่จะสัมผัสกับ DIY Zen แน่นอน

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

สัจพจน์ของหลักสูตรของเรา

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

คุณต้องเขียนโค้ดเอง ไม่ใช่คัดลอกตัวอย่าง ดังนั้นคุณจะจำได้มากและถ้าคุณคัดลอก - เพียงเล็กน้อย

ไม่จำเป็นต้องทำตามสีของสายไฟดังในไดอะแกรม สีสามารถเป็นสีใดก็ได้ไม่ส่งผลต่อการทำงานของโครงร่าง

ในการทดลองทั้งหมดของเรา (ระดับ 1) เราจะใช้ Arduino UNO และเขียงหั่นขนม พวกเขาจะไม่ได้อธิบายไว้ในส่วนประกอบที่จำเป็นสำหรับบทเรียน ฉันจะอธิบายพวกเขาในบทเรียนแรกเท่านั้น

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

เครื่องแรก

โครงการเล็ก ๆ แห่งแรกของเราจะเป็นสิ่งที่มีประโยชน์อย่างมากบนท้องถนน - สัญญาณไฟจราจร

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

เราจะพยายามสร้างสัญญาณไฟจราจรขนาดเล็ก นี่จะเป็นการเริ่มต้นที่สมบูรณ์แบบในการทำความรู้จักกับ Arduino

อัลกอริทึมสัญญาณไฟจราจร

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

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

ดังนั้นเราจึงหาอัลกอริทึม ตอนนี้เราต้องประกอบสัญญาณไฟจราจร

รายละเอียดสำหรับสัญญาณไฟจราจร

LED สีแดง 1 ชิ้น

LED สีเหลือง 1 ชิ้น

LED สีเขียว 1 ชิ้น

ตัวต้านทาน 220 โอห์ม 3 ชิ้น

สายเชื่อมต่อ "Papa-Papa" 7 ชิ้น

การประกอบ

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

โคดิม

ยอดเยี่ยม. เรามีสัญญาณไฟจราจรขนาดเล็ก และตอนนี้เราต้องทำให้สำเร็จ

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

ลองดูรหัส:

// ต่อไปเราจะเรียนรู้วิธีทำให้โค้ดกระชับและอ่านง่ายขึ้น แต่ก่อนอื่นเราต้องจัดการกับสิ่งนี้ void setup() ( pinMode(13, OUTPUT); // นี่คือไฟ LED สีเขียวของเรา เราระบุว่าเป็นเอาต์พุต pinMode(12,OUTPUT); // นี่คือสีเหลือง pinMode(11,OUTPUT); // นี่คือ สีแดง ) // ตอนนี้อัลกอริทึมของเราที่เขียนบนกระดาษจำเป็นต้องแปลเป็นโปรแกรม void loop() ( digitalWrite(11, HIGH); // เปิดไฟ LED สีแดง (5000); // รอจนสว่าง digitalWrite(12, สูง); // ไฟ LED สีเหลืองกับสีแดงสว่างขึ้น หน่วงเวลา (1,000) ; // รอสักครู่ digitalWrite(11, LOW); // ตอนนี้ปิดสีแดงและสีเหลือง, digitalWrite(12, LOW); digitalWrite(13, สูง); // และเปิดการหน่วงเวลาสีเขียว (5000); //รอจนสีเขียวทึบ digitalWrite(13, สูง); // กะพริบเป็นสีเขียว ส่วนนี้ย่อส่วนนี้ให้เล็กลงได้ เดี๋ยวจะเล่าให้ฟัง ); delay(800); digitalWrite(13, LOW); หน่วงเวลา(800); digitalWrite(13, สูง); หน่วงเวลา(800); digitalWrite(13, ต่ำ); // เปิดสีเหลืองและปิดสีเขียว digitalWrite(12, สูง ); หน่วงเวลา(1000); digitalWrite(12, ต่ำ ); // เราปิดการหน่วงเวลาสีเหลือง (10); // การวนซ้ำวนซ้ำเป็นจำนวนไม่สิ้นสุด )

ตอนนี้เรามีสัญญาณไฟจราจรที่ใช้งานได้

รหัสน้อย

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

ลองดูรหัสของเรา

// รหัสที่ถูกต้องเพิ่มเติม // เพื่อให้อ่านง่ายขึ้น ควรกำหนดสิ่งที่เรียกว่ามาโคร // มาโครทำงานเหมือนกับ "ค้นหาและแทนที่" ของ Word #define GREEN 13 // กำหนดพิน 13 เป็น Green #กำหนดสีเหลือง 12 // 12 เหมือนสีเหลือง #define RED 11 // 11 เปรียบเสมือนสีแดง // เราจำเป็นต้องสร้างตัวแปรเพื่อให้ทำงานได้ง่ายขึ้นเมื่อตั้งค่าพารามิเตอร์ของโปรแกรมและอ่านง่ายขึ้น int main_delay = 5,000; // เผาเวลาสำหรับ int สีแดงและสีเขียว mini_delay = 1,000; // สีเหลืองเขียนเวลา int blink_delay = 800; // การตั้งค่าโมฆะเวลากะพริบสีเขียว () ( pinMode (สีเขียว, OUTPUT); pinMode (สีเหลือง, OUTPUT); pinMode (RED, OUTPUT); ) void loop () ( digitalWrite (RED, HIGH); delay (main_delay); digitalWrite (สีเหลือง, สูง); delay(mini_delay); digitalWrite(RED, LOW); digitalWrite(YELLOW, LOW); digitalWrite(GREEN, HIGH); delay(main_delay); digitalWrite(GREEN, LOW); // ตอนนี้กะพริบเป็นสีเขียว. สามารถกระพริบได้โดยใช้สิ่งที่เรียกว่า counter loop: for(int i = 0; i< 3; i = i+1) { delay(blink_delay); digitalWrite(GREEN, HIGH); delay(blink_delay); digitalWrite(GREEN, LOW); } digitalWrite(YELLOW, HIGH); delay(mini_delay); digitalWrite(YELLOW, LOW); delay(mini_delay); } // Теперь наш код стал компактнее и читабельнее. // Но запомни, тебе следует давать осмысленные имена переменным и макроопределениям.Это улучшает читабельность. // Если ты через месяц откроешь свой код, ты поймешь о чем я говорю.

คำอธิบาย

สำหรับ- นี่คือสิ่งที่เรียกว่าลูปพร้อมตัวนับ ลูปนี้ทำซ้ำการกระทำที่อยู่ในวงเล็บจำนวนครั้งที่ระบุ ทำซ้ำกี่ครั้ง - ให้ไว้ในวงเล็บ

โดยทั่วไปสามารถเขียนได้ดังนี้

for(ตัวแปร;เงื่อนไข;การเปลี่ยนแปลง)

(รหัสที่จะทำซ้ำ)

ตัวแปร- ตัวแปรที่สร้างขึ้นเฉพาะสำหรับลูป จำเป็นเพื่อ "เริ่มต้น" วงจร นั่นคือเปรียบเทียบตัวแปรกับเงื่อนไขการวนซ้ำ

เงื่อนไข- เงื่อนไขภายใต้ความจริงซึ่งจะดำเนินการในวงเล็บปีกกา

เปลี่ยน- กฎที่ตัวแปรเปลี่ยนแปลง การเปลี่ยนแปลงจะเกิดขึ้นหลังจากตรวจสอบเงื่อนไขแล้ว หลังจากนั้นจะมีการตรวจสอบตัวแปรที่เปลี่ยนแปลง

สรุปบทเรียน

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

รายการองค์ประกอบวิทยุ