สะพานเทียนริบหรี่: 6 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:04

คำแนะนำนี้แสดงวิธีเปลี่ยนสะพานเทียนแบบเรียบง่ายด้วยแสงคงที่ให้เป็นแสงอารมณ์ที่เร่าร้อนด้วยแสงริบหรี่ ระยิบระยับ รูปแบบคลื่น และอีกมากมายไม่รู้จบ ฉันซื้อสะพานเทียนจาก After Christmas Sales ราคา 8 ยูโร มีไฟ LED 7 ดวงและอะแดปเตอร์ติดผนัง 33 V 3 W บางตัว มันส่องแสงด้วยสีขาวสว่างและอบอุ่น และจะสมบูรณ์แบบสำหรับโครงการนี้ โดยฉันจะใส่ Arduino เพื่อทำให้เทียนกะพริบ Arduino ที่ได้รับความนิยมมากที่สุดคือ Arduino Uno ในโครงการนี้ ฉันจะใช้ Arduino Mega 2560

ฉันจะทิ้งแหล่งจ่ายไฟ 30 V และจะใช้ธนาคารพลังงาน 5 V แบบง่ายสำหรับโทรศัพท์มือถือเป็นแหล่งจ่ายไฟ

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

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

• ไฟริบหรี่ 4 แบบ เลียนแบบเทียนจริง
• 2 กระพริบที่แตกต่างกัน (กระพริบแบบสุ่มของไฟคงที่อื่น ๆ)
• 2 รูปแบบคลื่นที่แตกต่างกัน
• ไฟสถิตย์ธรรมดา

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

เสบียง

• สะพานเทียน LED 1 ดวงพร้อมหลอดไฟ 7 ดวง ตรวจสอบให้แน่ใจว่าเป็นรุ่น DC แรงดันต่ำ ไม่ว่าจะใช้แบตเตอรี่หรือแหล่งจ่ายไฟแบบติดผนัง ซึ่งจะแปลงไฟ 110 - 240 V ที่อันตรายถึงตายเป็น 6 - 30 V DC ดังนั้นจึงปลอดภัยอย่างยิ่งที่จะแฮ็กสะพานเทียน
• 1 Arduino Mega (ไมโครคอนโทรลเลอร์ตัวอื่นๆ จะทำได้ เพียงให้แน่ใจว่าคุณสามารถตั้งโปรแกรมได้)
• 1 เขียงหั่นขนมต้นแบบ
• สายจัมเปอร์และสายอื่นๆ
• เครื่องมือบัดกรี
• มัลติมิเตอร์
• ตัวต้านทาน 7 ตัว 120 Ω
• 1 ปุ่มกด (ฉันจะแสดงวิธีใช้ปุ่มในตัวบน Arduino แทน)
• IC ทรานซิสเตอร์ดาร์ลิงตันสำหรับทรานซิสเตอร์ 7 ตัว ULN2803AP จะทำ (ถ้าคุณใช้ Arduino Uno หรือ Meaga คุณไม่ต้องการสิ่งนี้จริงๆ)
• พาวเวอร์แบงค์ 5 V สำหรับโทรศัพท์มือถือ

ขั้นตอนที่ 1: ตรวจสอบสิ่งที่คุณได้รับ

ค้นหาว่า LED แต่ละดวงทำงานด้วยแรงดันไฟฟ้าเท่าใดและกระแสไฟไหลผ่านเท่าใด

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

การอ่านของฉัน

แรงดันไฟเหนือหนึ่งเทียน (ขั้นตอนที่ 3): 3.1 V

โปรดทราบว่าแหล่งพลังงานของสะพานเทียนคือ 33 V ดังนั้นเจ็ดคูณ 3.1 V มีเพียง 21.7 V สำหรับเทียนบางอันจะต้องมีตัวต้านทานเพิ่มเติม ถ้าฉันวัดแรงดันเทียนนั้น มันต้องมีค่าเท่ากับ 11 V

กระแสไฟไหลผ่านเมื่อจุดเทียน (ขั้นตอนที่ 4): 19 mA

ฉันจะเพิ่มพลังให้ทุกอย่างด้วยก้อนแบตเตอรี่ 5 V 2 A สำหรับเทียน ฉันต้องลดแรงดันไฟฟ้าจาก 5 V เป็น 3 V ฉันต้องการตัวต้านทาน ซึ่งจะลดแรงดันไฟฟ้า 2 V ที่กระแส 19 mA

2 V / 0.019 A = 105 Ω

พลังงานที่สูญเสียไปคือ:

2 V * 19 mA = 38 mW

นั่นเป็นเรื่องเล็กน้อย อีกมากสามารถระเบิดตัวต้านทานเองได้ หากไม่มีตัวต้านทาน 105 Ω ฉันอาจทำให้ LED ระเบิดได้ ฉันมีตัวต้านทาน 100 Ω และ 120 Ω ฉันไปกับ 120 Ω มันให้การปกป้องที่มากกว่า

การทดสอบเทียนทั้ง 7 ดวงที่มี 3 V ให้แสงสว่าง ยกเว้นเทียนเล่มหนึ่งซึ่งมีแสงสลัวมาก โดยมีเพียง 0.8 mA เท่านั้นที่ผ่านไป นี่คือเทียนของฉันที่มีตัวต้านทานพิเศษ ปรากฎว่าเทียนเล่มอื่นไม่มีตัวต้านทานเลย ไฟ LED ที่ใช้ในโคมระย้านั้นมีไว้สำหรับ 3 V! ต้องเปิดเทียนที่มีตัวต้านทานเพิ่มเติมโดยใช้ความรุนแรงเล็กน้อย แต่ไม่มีอะไรหัก พบตัวต้านทานอยู่ใต้ LED เล็กๆ ภายในหลอดเทียนพลาสติก ฉันต้องถอดมันออกและขายสายไฟต่อ มันค่อนข้างเลอะเทอะเล็กน้อย เนื่องจากหัวแร้งทำให้กาวร้อนซึ่งใช้สำหรับการประกอบนั้นอุ่นขึ้น

ตอนนี้ฉันรู้แล้วว่าแหล่งพลังงานใดก็ตามที่ฉันใช้ ไม่ว่าแรงดันไฟฟ้าจะเป็นอย่างไร ฉันต้องลดแรงดันไฟฟ้าลงเหลือ 3 V โดยปล่อยให้ 19 mA ผ่านได้

ถ้าฉันคุ้นเคยกับเทคโนโลยี LED มากขึ้น ฉันจะรู้จักประเภทของ LED ที่ใช้และรู้ว่าต้องใช้ 3 V

ขั้นตอนที่ 2: การบัดกรีบางส่วน

ในขั้นตอนนี้ ฉันเชื่อมต่อสายบวก (+) ทั้งหมดจากเทียน 5 แท่งเป็นเส้นเดียว จากนั้นฉันก็เพิ่มเส้นลวดลบ (-) แยกต่างหากสำหรับเทียนแต่ละอัน ไฟ LED จะสว่างเมื่อ '+' และ '-' ไปทางขวาเท่านั้น เนื่องจากคุณมีเพียงสองปลายสายที่เหมือนกันจากแต่ละเทียน คุณต้องทดสอบว่าอันไหนคือ '+' และอันไหนคือ '-' สำหรับสิ่งนี้ คุณต้องใช้แหล่งพลังงาน 3 V ฉันมีแพ็คเกจแบตเตอรี่ขนาดเล็กพร้อมแบตเตอรี่ AAA สองก้อน แบตเตอรี่แบบเหรียญ 3 V ก็ใช้งานได้ดีสำหรับการทดสอบเช่นกัน

สะพานเทียนต้องใช้สายเคเบิล 8 เส้นเพื่อวิ่งระหว่าง Arduino และบริดจ์ ถ้าเจอสายไฟหุ้มฉนวน 8 เส้นจะดีมาก สายไฟหนึ่งเส้นต้องมี 120 mA ส่วนที่เหลือมีเพียง 20 mA เท่านั้น ฉันเลือกใช้สายเคเบิลคู่ 4 เส้นซึ่งบังเอิญมี

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

ภาพที่สองแสดงเส้นลวด '-' ที่แต่ละแท่งเทียนต้องการ สาย '+' ทั่วไปจะตรงไปยังพิน 5 V ของ Arduino (หรืออาจผ่านทางเขียงหั่นขนม) ลวด '-' แต่ละเส้นจะไปที่ขาของทรานซิสเตอร์ IC (อีกครั้ง อาจผ่านทางเขียงหั่นขนม)

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

ขั้นตอนที่ 3: การเชื่อมต่อ

เกี่ยวกับ Arduinos นำมาจากหน้านี้:

• กระแสไฟสูงสุดทั้งหมดต่อขาอินพุต/เอาต์พุต: 40mA
• ผลรวมของกระแสจากพินอินพุต/เอาต์พุตทั้งหมดรวมกัน: 200mA

เทียนของฉันวาดแต่ละอัน 19 mA เมื่อขับเคลื่อนโดย 3 V มีเจ็ดแท่งซึ่งทำให้ 133 mA ดังนั้นฉันจึงสามารถจ่ายไฟได้โดยตรงจากพินเอาต์พุต อย่างไรก็ตาม ฉันมีไอซีทรานซิสเตอร์ดาร์ลิงตันสำรองอยู่บ้าง ฉันก็เลยคิดว่าทำไมไม่ วงจรของฉันทำในสิ่งที่ถูกต้อง: หมุดข้อมูลมีไว้สำหรับสัญญาณเท่านั้น ไม่ใช่สำหรับกำลัง แต่ฉันใช้พิน 5 V บน Arduino เพื่อจ่ายไฟให้กับไฟ LED เมื่อทดสอบการทำงาน ฉันมีแล็ปท็อปเชื่อมต่อกับ Arduino ทุกอย่างใช้พลังงานจาก USB ของแล็ปท็อปซึ่งให้ 5 V Arduino Mega มีฟิวส์ของตัวเองซึ่งจะระเบิดที่ 500 mA เพื่อปกป้องคอมพิวเตอร์ เทียนของฉันวาดมากที่สุด 133 mA Arduino อาจน้อยกว่ามาก ทุกอย่างทำงานได้ดีเมื่อใช้พลังงานจากแล็ปท็อป ดังนั้นการใช้ชุดแบตเตอรี่ 5 V ที่เชื่อมต่อกับพอร์ต USB ของ Arduino นั้นใช้ได้ดี

หมุดข้อมูล D3 - D9 ไปที่ IC ULN2803APGCN ไฟ LED ทำงานบน 3 V หลอดไฟแต่ละหลอดเชื่อมต่อกับแหล่งจ่าย 5 V และต่อกับตัวต้านทาน 120 Ω เพิ่มเติมไปยังช่องสัญญาณหนึ่งช่องของ IC ซึ่งสุดท้ายเชื่อมต่อวงจรกับกราวด์ผ่านทรานซิสเตอร์ดาร์ลิงตันใน IC

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

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

ภาพถ่ายแสดงให้เห็นว่าสายเคเบิลใหม่ออกมาจากบริดจ์ได้อย่างไร ฉันวางทรานซิสเตอร์ IC และตัวต้านทานบนเขียงหั่นขนมได้อย่างไร และวิธีที่สายจัมเปอร์เชื่อมต่อกับ Arduino Mega ฉันตัดสายจัมเปอร์ตัวผู้-ตัวผู้ 4 เส้นออกเป็นครึ่งสาย 8 เส้น ซึ่งฉันบัดกรีกับสาย 8 เส้นที่ออกมาจากสะพานเทียน ด้วยวิธีนี้ฉันสามารถติดสายเคเบิลเข้ากับเขียงหั่นขนมได้

ทางเลือกที่ไม่มีทรานซิสเตอร์

ในขั้นตอนที่แล้ว ฉันได้เตรียมลวด '+' ทั่วไปสำหรับเทียนและแยกสายไฟ '-' ซึ่งผ่านทรานซิสเตอร์ IC ลงไปที่พื้น เมื่อดาต้าพินหนึ่งพินสูง ลวด '-' ที่สอดคล้องกันจะต่อกราวด์ผ่านทรานซิสเตอร์และไฟ LED

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

ขั้นตอนที่ 4: โปรแกรมไลท์

โปรแกรมของฉันซึ่งฉันนำเสนอในขั้นตอนต่อไป ต้องผ่าน 9 โปรแกรมแสง การกดปุ่มจะทำให้ไฟดับลงครู่หนึ่ง จากนั้นโปรแกรมไฟต่อไปนี้จะเริ่มทำงาน โปรแกรมมีดังนี้:

1. ริบหรี่อย่างแรง เทียนจะกะพริบแบบสุ่ม สิ่งนี้ดูน่ารำคาญมากเมื่อคุณจ้องมองพวกมันจากระยะใกล้ แต่อาจดูดีจากระยะไกลและบางทีอาจอยู่หลังหน้าต่างห้องใต้หลังคาที่หนาวจัด แม้ว่าเพื่อนบ้านของคุณอาจเรียกหน่วยดับเพลิง
2. ริบหรี่อย่างนุ่มนวล ดูดีมาก เหมือนเทียนจริงในห้องที่ไม่มีร่าง
3. ริบหรี่ที่ต่างกันออกไป แท่งเทียนจะสลับกันอย่างราบรื่นระหว่างการริบหรี่อย่างแรงและอ่อนในช่วง 30 วินาที
4. ริบหรี่ต่างๆ. เช่นเดียวกับ #3 แต่เทียนแต่ละแท่งแตกต่างกันไปตามจังหวะของตัวเองระหว่าง 30 และ 60 วินาที
5. กระพริบตาเร็ว เทียนส่องไปที่ระดับสลัวคงที่และกระพริบตาแบบสุ่ม โดยเฉลี่ยแล้วจะมีหนึ่งชั่วพริบตาทุกวินาที
6. กระพริบตาช้าๆ เช่น #5 แต่ในอัตราที่ช้ากว่ามาก
7. คลื่นเร็วจากแท่งเทียนตรงกลางไปยังแท่งล่าง
8. คลื่นช้าจากแท่งเทียนตรงกลางไปยังแท่งล่าง
9. แสงสถิตย์. ฉันต้องรวมสิ่งนี้ไว้ ไม่ต้องการกำจัดฟังก์ชั่นดั้งเดิม

ขั้นตอนที่ 5: รหัส

/*

สะพานเทียนกะพริบ */ // ประกาศตัวแปรโหมดเพื่อคงสถานะ // ผ่านการรีเซ็ต _attribute_((section(".noinit"))) โหมด int ที่ไม่ได้ลงชื่อ; // เมื่อโปรแกรมเริ่มทำงานหลังจากการรีเซ็ต ส่วนนี้ // ของหน่วยความจำจะไม่ถูกเตรียมใช้งาน แต่คงค่าไว้ // ที่มีอยู่ก่อนการรีเซ็ต ครั้งแรกที่รันโปรแกรม // โปรแกรมจะเก็บค่าสุ่มไว้ /* * คลาสเทียนมีทุกสิ่งที่จำเป็น * สำหรับการคำนวณระดับแสงสำหรับ * เทียนริบหรี่ */ เทียนคลาส { ส่วนตัว: maxtime ยาว; mintime นาน; แมกซ์ไลต์ยาว minlite ยาว; มีนไลท์ยาว origmaxtime ยาว; ต้นทางยาว; origmaxlite ยาว; origminlite ยาว; origmeanlite ยาว; deltamaxtime นาน; deltamintime นาน; เดลทาแมกซ์ไลต์ยาว เดลทามินไลต์ยาว เดลตามีนไลต์ยาว lforate ยาว; ยาวสม่ำเสมอ; เริ่มต้นนาน; เป้าหมายยาว แฟคเตอร์ลอย; เวลาเป้าหมายนาน เวลาเริ่มต้นนาน เวลาเดลต้านาน เป็นโมฆะ newtarget(เป็นโมฆะ); onetarget ยาว (เป็นโมฆะ); สาธารณะ: เทียน (เสื่อยาว, ยาว mit, mal ยาว, ยาว mil, ยาว mel, ลอง eo); ระดับยาวตอนนี้(เป็นโมฆะ); เป็นโมฆะ initlfo (เดลทามาทยาว, เดลทามิทยาว, เดลทามัลยาว, เดลทามิลยาว, เดลตามีนยาว, อัตรายาว); โมฆะ setlfo(โมฆะ); }; candle::candle(long mat, long mit, long mal, long mil, long mel, long eo): maxtime(mat), mintime(mit), maxlite(mal), minlite(mil), meanlite(mel),evenout เทียน::เทียน (eo), origmaxtime(mat), origmintime(mit), origmaxlite(mal), origminlite(mil), origmeanlite(mel) { target = meanlite; เป้าหมายใหม่ (); } /* * levelnow() คืนค่าระดับแสงที่เทียนควรมีในขณะนี้ * ฟังก์ชันจะดูแลการกำหนดระดับแสงสุ่มใหม่และ * เวลาที่ควรใช้เพื่อไปถึงระดับนั้น การเปลี่ยนแปลงไม่เป็นเชิงเส้น * แต่เป็นไปตามเส้นโค้งซิกมอยด์ เมื่อยังไม่ถึงเวลากำหนดระดับ * ใหม่ ฟังก์ชันจะคืนค่าระดับแสงเท่านั้น */ long candle::levelnow(void) { ช่วยด้วย ตอนนี้; ลอย t1, t2; ตอนนี้ = millis(); ถ้า (ตอนนี้ >= เวลาเป้าหมาย) { ช่วย = เป้าหมาย; เป้าหมายใหม่ (); ส่งคืนความช่วยเหลือ; } else { //help = target * (มิลลิวินาที () - เวลาเริ่มต้น) / deltatime + start * (เวลาเป้าหมาย - มิลลิวินาที ()) / deltatime; t1 = float(เวลาเป้าหมาย - ตอนนี้) / deltatime; t2 = 1. - t1; // นี่คือความช่วยเหลือในการคำนวณ sigmoid = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; ส่งคืนความช่วยเหลือ; } } โมฆะเทียน::newtarget(โมฆะ) { ผลรวมยาว; ผลรวม = 0; สำหรับ (ยาว i = 0; i < สม่ำเสมอ; i++) sum += onetarget(); เริ่ม = เป้าหมาย; เป้าหมาย = ผลรวม / สม่ำเสมอ; เวลาเริ่มต้น = มิลลิวินาที (); เวลาเป้าหมาย = เวลาเริ่มต้น + สุ่ม (เวลาต่ำสุด, เวลาสูงสุด); deltatime = เวลาเป้าหมาย - เวลาเริ่มต้น; } แท่งเทียนยาว::onetarget (เป็นโมฆะ) { ถ้า (สุ่ม (0, 10) ตรวจสอบล่าสุด + 100) { ตรวจสอบล่าสุด = ตอนนี้; /* * algo สำหรับการกระพริบตา "หลังอัตรามิลลิวินาที": * เริ่มตรวจสอบหลังจากอัตรา / 2 มิลลิวินาที * ในช่วงระยะเวลาของอัตรา / 2 มิลลิวินาที ทำให้ * มีโอกาสกระพริบตาเป็น 50% * ถ้าอัตรา 10000 ms ระหว่าง 5000 ms เหรียญจะ * พลิก 50 ครั้ง * 1/50 = 0.02 * หากสุ่ม (10000) เวลาเริ่มต้น + อัตรา / 2) { ถ้า (สุ่ม (อัตรา) เวลาเป้าหมาย) คืนค่า lowlite; กลับ (เริ่ม - ต่ำ) * (เวลาเป้าหมาย - ตอนนี้) / (เวลาเป้าหมาย - เวลาเริ่มต้น) + ต่ำ; } void twinkler::twink(void) { เวลาเริ่มต้น = millis(); เวลาเป้าหมาย = สุ่ม (เวลาต่ำสุด, สูงสุด) + เวลาเริ่มต้น; เริ่ม = สุ่ม (minlite, maxlite); } การตั้งค่าเป็นโมฆะ () { int led; // อ่านตัวแปรโหมดเวทย์มนตร์ซึ่งควรบอก // โปรแกรมแสงใดที่รันครั้งล่าสุด เพิ่มขึ้น // และรีเซ็ตเป็นศูนย์หากล้น โหมด++; โหมด %= 9; // สิ่งนี้จะดูแลสิ่งที่มีค่า // เป็นครั้งแรกที่ Arduino // รันโปรแกรมนี้ /* * หมายเหตุสำคัญ * ============== * * สิ่งสำคัญที่โปรแกรมนี้ทำคือการส่งสัญญาณ PWM * ไปยังไฟ LED ที่นี่ฉันตั้งพิน 3 ถึง 9 เป็นโหมดเอาต์พุต * บน Arduino Mega2560 พินเหล่านี้ส่งออก * สัญญาณ PWM อย่างดี หากคุณมี Arduino ตัวอื่น ให้ตรวจสอบ * พินใด (และจำนวนเท่าใด) ที่คุณสามารถใช้ได้ คุณสามารถ * เขียนโค้ดใหม่เพื่อใช้ซอฟต์แวร์ PWM ได้ตลอดเวลา หาก Arduino * ของคุณมีพิน PWM ของฮาร์ดแวร์ไม่เพียงพอ * */ โหมดพิน (3, เอาต์พุต); โหมดพิน (4, เอาต์พุต); โหมดพิน (5, เอาต์พุต); โหมดพิน(6, เอาต์พุต); โหมดพิน (7, เอาต์พุต); โหมดพิน (8, เอาต์พุต); โหมดพิน (9, เอาต์พุต); โหมดพิน (LED_BUILTIN, เอาต์พุต); analogWrite (LED_BUILTIN, 0); // เพียงแค่ปิดไฟ LED สีแดงที่น่ารำคาญบนเทียน Arduino *can[7]; // เตรียมใช้เทียนริบหรี่ ไม่ว่าคุณจะใช้หรือไม่กระพริบตา *กระพริบตา[7]; // เตรียมใช้แสงเทียนระยิบระยับ… if (mode == 8) { for (int i = 3; i < 10; i++) analogWrite(i, 255); ในขณะที่ (จริง); // ทุกครั้งที่โปรแกรมนี้ทำงาน มันจะเข้าสู่ // วนซ้ำไม่รู้จบแบบนี้ จนกว่าจะกดปุ่มรีเซ็ต // } if (mode < 2) // กะพริบ { maxtime_ ยาว; mintime ยาว_; maxlite ยาว _; minlite ยาว_; มีนไลท์ยาว_; ยาวสม่ำเสมอ_; ถ้า (โหมด == 0) { maxtime_ = 250; นาที_ = 50; maxlite_ = 256; minlite_ = 0; มีนไลท์_ = 128; แม้กระทั่ง_ = 1; } ถ้า (โหมด == 1) { maxtime_ = 400; นาที_ = 150; maxlite_ = 256; minlite_ = 100; มีนไลท์_ = 200; แม้กระทั่ง_ = 1; } สำหรับ (int i = 0; i <7; i++) { can = เทียนใหม่ (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } ในขณะที่ (จริง) // วงวนไม่มีที่สิ้นสุดสำหรับเทียนริบหรี่ { สำหรับ (int i = 0; i levelnow()); } } if (โหมด < 4) // lfo เพิ่มในการกะพริบ { if (mode == 2) // lfo เดียวกัน (30 วินาที) สำหรับเทียนทั้งหมด { สำหรับ (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000); } } if (mode == 3) // เปลี่ยนแปลง lfo:s สำหรับเทียน { สำหรับ (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); สามารถ[1]->initlfo(75, 50, 0, 50, 36, 25000); can[2]->initlfo(75, 50, 0, 50, 36, 30000); can[3]->initlfo(75, 50, 0, 50, 36, 35000); สามารถ[4]->initlfo(75, 40, 0, 50, 36, 40000); สามารถ[5]->initlfo(75, 30, 0, 50, 26, 45000); can[6]->initlfo(75, 20, 0, 50, 16, 50000); can[7]->initlfo(75, 10, 0, 50, 6, 55000); } ในขณะที่ (จริง) // การวนซ้ำไม่รู้จบสำหรับการสั่นเทียนด้วย lfo { long lastclock = 0; for (int i = 0; i levelnow()); if (millis() > lastclock + 4000) { lastclock = millis(); for (int i = 0; i setlfo(); } } } if (mode < 6) // เทียนวิบวับ { int speedo; if (mode == 4) speedo = 6000; else speedo = 22000; for (int i = 0; i < 7; i++) twink = มือใหม่ (300, 295, 255, 250, speedo); while (true) { for (int i = 0; i levelnow()); } } // คลื่น // ส่วนนี้เริ่มต้นด้วยวงเล็บปีกกาเพียง // เพื่อให้แน่ใจว่าไม่มีชื่อตัวแปรที่ขัดแย้งกัน // ไม่ต้องใช้วงเล็บ ไม่ต้องตรวจสอบ // ค่าของโหมด{ int lolite = 2; int hilite = 255; ค่าเฉลี่ย int; int แอมป์; float fasedelta = 2.5; ลอยตัว; int ยาว; แฟคเตอร์ลอย; ระยะเวลานาน ค่าเฉลี่ย = (lolite + hilite) / 2; ampl = hilite - หมายถึง; ถ้า (โหมด == 6) ระยะเวลา = 1500; ช่วงเวลาอื่น = 3500; phactor = 6.28318530718 / ระยะเวลา; ในขณะที่ (จริง) { fase = phactor * (มิลลิวินาที () % ระยะเวลา); elong = ค่าเฉลี่ย + ampl * บาป (fase); analogWrite(7, ยาว); analogWrite (9, ยาว); fase = phactor * ((มิลลิวินาที() + ระยะเวลา / 4) % ระยะเวลา); elong = ค่าเฉลี่ย + ampl * บาป (fase); analogWrite(3, ยาว); analogWrite(8, ยาว); fase = phactor * ((มิลลิวินาที () + ระยะเวลา / 2) % ระยะเวลา); elong = ค่าเฉลี่ย + ampl * บาป (fase); analogWrite (4, ยาว); analogWrite(5, ยาว); fase = phactor * ((มิลลิวินาที () + 3 * ระยะเวลา / 4) % ระยะเวลา); elong = ค่าเฉลี่ย + ampl * บาป (fase); analogWrite(6, ยาว); } // ในขณะที่เชื่อมต่อสายเทียนกับ Arduino // ฉันผสมมันและไม่เคยได้ตามลำดับ // ลำดับมีความสำคัญสำหรับการสร้างรูปแบบคลื่น // ดังนั้นฉันจึงเขียนตารางเล็ก ๆ นี้ให้ฉัน: // // Candle# ในบริดจ์: 2 3 5 4 7 6 1 // ดาต้าพินบน Arduino: 3 4 5 6 7 8 9 } } void loop() { // เนื่องจากทุกโปรแกรม light เป็น infinite loop ของตัวเอง // ฉันเขียนลูปทั้งหมดในส่วนเริ่มต้น () // และไม่เหลืออะไรเลยสำหรับส่วน loop() นี้ }

ขั้นตอนที่ 6: เกี่ยวกับ PWM

ไฟ LED จะส่องสว่างเมื่อจ่ายไฟ 3 V ใช้เพียง 1.5 V จะไม่ติดสว่างเลย ไฟ LED จะไม่ซีดจางอย่างสวยงามด้วยแรงดันไฟที่ซีดจาง เช่นเดียวกับหลอดไส้ แต่ต้องเปิดด้วยแรงดันไฟฟ้าเต็มแล้วจึงปิด เมื่อสิ่งนี้เกิดขึ้น 50 ครั้งต่อวินาที พวกมันจะส่องแสงอย่างสวยงามด้วยความสว่าง 50% ไม่มากก็น้อย หากอนุญาตให้เปิดเพียง 5 ms และปิด 15 ms พวกมันอาจส่องแสงด้วยความสว่าง 25% เทคนิคนี้เป็นสิ่งที่ทำให้ไฟ LED หรี่แสงได้ เทคนิคนี้เรียกว่าการปรับความกว้างพัลส์หรือ PWM ไมโครคอนโทรลเลอร์อย่าง Arduino มักจะมีดาต้าพิน ซึ่งสามารถส่งสัญญาณเปิด/ปิดได้ หมุดข้อมูลบางตัวมีความสามารถสำหรับ PWM แต่ถ้ามีพินไม่เพียงพอกับ PWM ในตัว ก็มักจะสามารถใช้ไลบรารีการเขียนโปรแกรมเฉพาะเพื่อสร้าง "พิน PWM ของซอฟต์แวร์"

ในโครงการของฉัน ฉันเคยใช้ Arduino Mega2560 ซึ่งมีฮาร์ดแวร์ PWM บนพิน 3 - 9 หากคุณใช้ Arduino UNO คุณจะมีพิน PWM เพียงหกพินเท่านั้น ในกรณีนั้น หากคุณต้องการเทียนแท่งที่ 7 (หรือมากกว่านั้น) ฉันสามารถแนะนำไลบรารี PWM ซอฟต์แวร์ของ Brett Hagman ซึ่งคุณสามารถหาได้ที่นี่