การปรับปรุง Arduino LED Mood Cube (แบบง่าย) (รวมวิดีโอ): 4 ขั้นตอน

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

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

ขั้นตอนที่ 1: วัสดุ

นี่คือวัสดุบางส่วนที่คุณต้องใช้ในการสร้าง Mood Cube:

• เขียงหั่นขนม
• Arduino - (ฉันมี Leonardo ที่นี่)
• แหล่งจ่ายไฟ Arduino / สาย USB
• เขียงหั่นขนม
• Jumper Wires (ส่วนใหญ่ฉันใช้ 29 สาย)
• ไฟ LED สีแดง x 2
• ไฟ LED สีฟ้า x 2
• ไฟ LED สีเขียว x 2
• ไฟ LED สีเหลือง x 2
• LED สีขาว x 1
• ตัวต้านทาน 9 ตัว
• กล่องใหญ่พอที่จะใส่เขียงหั่นขนม (ฉันใช้กล่องรองเท้า)
• มีดยูทิลิตี้
• กระดาษ

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

คำอธิบายบางอย่างสำหรับรหัสที่ให้ไว้ที่นี่:

เครดิตของรหัสไปที่แหล่งที่มาดั้งเดิมของโครงการของฉันเนื่องจากบรรณาธิการของโครงการสร้างรหัสเหล่านี้ ฉันแค่ปรับปรุงบางส่วนด้วยการทำให้ซับซ้อนขึ้น ในบางโค้ด คุณอาจเห็น //改 ต่อท้าย ซึ่งหมายความว่าฉันเป็นผู้แก้ไขโค้ดนี้ ดังนั้นจึงแตกต่างจากแหล่งที่มาเดิมของฉัน

ฉันยังมีรหัสเวอร์ชันบน Arduino Creator

/* รหัสสำหรับไฟ LED แบบ cross-fading 3 ดวง สีแดง สีเขียว และสีน้ำเงิน (RGB) ในการสร้างการจาง คุณต้องทำสองสิ่ง: 1. อธิบายสีที่คุณต้องการให้แสดง 2. ระบุลำดับที่คุณต้องการให้สีจางลง

อธิบายสี:

สีเป็นเพียงอาร์เรย์ของสามเปอร์เซ็นต์ 0-100 ควบคุม LED สีแดง สีเขียว และสีน้ำเงิน

สีแดงคือไฟ LED สีแดงเต็ม น้ำเงินและเขียวดับ

int red = {100, 0, 0 } สีขาวสลัวคือไฟ LED ทั้งสามดวงที่ 30% int dimWhite = {30, 30, 30} เป็นต้น

บางสีทั่วไปมีให้ด้านล่างหรือทำด้วยตัวเอง

แสดงรายการคำสั่งซื้อ:

ในส่วนหลักของโปรแกรม คุณต้องแสดงรายการลำดับที่คุณต้องการให้สีปรากฏ เช่น crossFade(สีแดง); crossFade(สีเขียว); crossFade(สีน้ำเงิน);

สีเหล่านั้นจะปรากฏตามลำดับ จางหายไปจาก

หนึ่งสีและต่อไป

นอกจากนี้ยังมีการตั้งค่าเสริม 5 แบบที่คุณสามารถปรับเปลี่ยนได้:

1. สีเริ่มต้นถูกตั้งค่าเป็นสีดำ (เพื่อให้สีแรกจางลง) แต่คุณสามารถตั้งค่าสีเริ่มต้นให้เป็นสีอื่นๆ ได้ 2. ลูปภายในจะทำงานสำหรับ 1,020 ครั้ง; ตัวแปร 'รอ' กำหนดระยะเวลาโดยประมาณของครอสเฟดเดียว ตามทฤษฎีแล้ว 'รอ' 10 ms ควรทำ crossFade ประมาณ 10 วินาที ในทางปฏิบัติ ฟังก์ชันอื่นๆ ที่โค้ดทำงานช้าลงเหลือ ~11 วินาทีบนกระดานของฉัน วายเอ็มเอ็มวี 3. หากตั้งค่า 'ซ้ำ' เป็น 0 โปรแกรมจะวนซ้ำไปเรื่อย ๆ หากตั้งค่าเป็นตัวเลข จะวนซ้ำตามจำนวนนั้น แล้วหยุดที่สีสุดท้ายในลำดับ (ตั้งค่า 'return' เป็น 1 และทำให้สีสุดท้ายเป็นสีดำถ้าคุณต้องการให้มันจางหายไปในตอนท้าย) 4. มีตัวแปร 'hold' ที่เป็นตัวเลือก ซึ่งจะหยุดโปรแกรมสำหรับ 'hold' มิลลิวินาทีเมื่อสีอยู่ เสร็จแต่ก่อนสีต่อไปจะเริ่ม 5. ตั้งค่าแฟล็ก DEBUG เป็น 1 หากคุณต้องการส่งเอาต์พุตการดีบักไปยังมอนิเตอร์แบบอนุกรม

ภายในของโปรแกรมไม่ซับซ้อน แต่พวกมัน

จุกจิกเล็กน้อย -- อธิบายการทำงานภายในด้านล่างลูปหลัก

เมษายน 2550, Clay Shirky

*

/ เอาท์พุต

int ylwPin = 5; // LED สีเหลืองเชื่อมต่อกับพินดิจิตอล 5 //改 int redPin = 6; // LED สีแดง เชื่อมต่อกับพินดิจิตอล 6 //改 int grnPin = 7; // ไฟ LED สีเขียว เชื่อมต่อกับพินดิจิตอล 7 //改 int bluPin = 8; // LED สีน้ำเงิน เชื่อมต่อกับพินดิจิตอล 8 //改 int whiPin = 9; // LED สีขาว เชื่อมต่อกับพินดิจิตอล 9 //改 int ylwPin2 = 10; // LED สีเหลืองเชื่อมต่อกับพินดิจิตอล 10 //改 int redPin2 = 11; // LED สีแดง เชื่อมต่อกับพินดิจิตอล 11 //改 int grnPin2 = 12; // ไฟ LED สีเขียว เชื่อมต่อกับพินดิจิตอล 12 //改 int bluPin2 = 13; // LED สีน้ำเงิน ต่อกับขาดิจิตอล 13 //改

// อาร์เรย์สี

int black[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };//改 int สีขาว[9] = { 100, 100, 100, 100, 100, 100, 100, 100, 100 };//改 int red[9] = { 0, 0, 100, 0, 0, 0, 100, 0, 0 };//改 int สีเขียว[9] = { 0, 100, 0, 0, 0, 0, 0, 100, 0 };//改 int blue[9] = { 0, 0, 0, 100, 0, 0, 0, 0, 100 };//改 int สีเหลือง[9] = { 100, 0, 0, 0, 0, 100, 0, 0, 0 }; //改 int สีม่วง[9] = { 0, 50, 0, 50, 0, 0, 50, 0, 50 }; //改 สีส้ม [9] = { 50, 50, 0, 0, 0, 50, 50, 0, 0 }; //改 สีชมพู [9] = { 0, 50, 0, 0, 50, 0, 0, 50, 0, }; // 改 // ฯลฯ

// ตั้งค่าสีเริ่มต้น

int redVal = สีดำ[0]; int grnVal = สีดำ [1]; int bluVal = สีดำ[2]; int ylwVal = สีดำ[3]; //改 int whiVal = สีดำ[4]; //改

รอสักครู่ = 15; // 10ms หน่วงเวลา crossFade ภายใน; เพิ่มขึ้นสำหรับการจางที่ช้าลง //改

int ถือ = 1; // ตัวเลือกการพักเมื่อสีเสร็จสมบูรณ์ ก่อน crossFade ถัดไป //改 int DEBUG = 1; // เคาน์เตอร์ DEBUG; หากตั้งค่าเป็น 1 จะเขียนค่ากลับผ่าน serial int loopCount = 60; // DEBUG ควรรายงานบ่อยแค่ไหน? int ซ้ำ = 0; // เราควรวนซ้ำกี่ครั้งก่อนที่จะหยุด? (0 ไม่หยุด) //改 int j = 0; // ตัวนับวนซ้ำ

// เริ่มต้นตัวแปรสี

int ก่อนหน้า = redVal; int ก่อนหน้า = grnVal; int ก่อนหน้า = bluVal; int ก่อนหน้า = ylwVal; int ก่อนหน้า = whiVal; //改

// ตั้งค่าเอาต์พุต LED

การตั้งค่าเป็นโมฆะ () {pinMode (redPin, OUTPUT); // ตั้งค่าพินเป็นเอาต์พุต pinMode(grnPin, OUTPUT); โหมดพิน (บลูพิน, เอาต์พุต); pinMode(ylwPin, เอาต์พุต); //改 pinMode(whiPin, OUTPUT); //改 pinMode(grnPin2, OUTPUT); //改 pinMode(bluPin2, OUTPUT); //改 pinMode(ylwPin2, OUTPUT); //改 pinMode(redPin2, OUTPUT); //改

if (DEBUG) { // หากเราต้องการดูค่าสำหรับการดีบัก…

Serial.begin(9600); // …ตั้งค่าเอาต์พุตอนุกรม } }

// โปรแกรมหลัก: แสดงรายการลำดับของ crossfades

วงเป็นโมฆะ () { crossFade (สีแดง); crossFade(สีเขียว); crossFade(สีน้ำเงิน); crossFade(สีเหลือง); crossFade(สีขาว); crossFade(สีชมพู); crossFade(สีม่วง); crossFade(สีส้ม);

if (repeat) { // เราวนซ้ำจำนวน จำกัด หรือไม่?

เจ += 1; if (j >= ซ้ำ) { // เราอยู่ที่นั่นหรือยัง? ทางออก(j); //ถ้าอย่างนั้นก็หยุดเถอะ } } }

/* ด้านล่างบรรทัดนี้เป็นคณิตศาสตร์ -- คุณไม่จำเป็นต้องเปลี่ยนแปลงสิ่งนี้สำหรับพื้นฐาน

โปรแกรมทำงานดังนี้:

ลองนึกภาพ crossfade ที่ย้าย LED สีแดงจาก 0-10 สีเขียวจาก 0-5 และสีน้ำเงินจาก 10 เป็น 7 ในสิบขั้นตอน เราต้องการนับ 10 ขั้นตอนและเพิ่มหรือลดค่าสีโดยเพิ่มขึ้นทีละขั้นเท่าๆ กัน ลองนึกภาพ a + หมายถึงการเพิ่มค่าขึ้น 1 และ a - เท่ากับการลดค่าลง เฟด 10 ขั้นตอนของเราจะมีลักษณะดังนี้:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + G + + + + + B - - -

สีแดงเพิ่มขึ้นจาก 0 เป็น 10 ในสิบขั้น สีเขียวจาก

0-5 ใน 5 ขั้นตอน และสีน้ำเงินตกจาก 10 เป็น 7 ในสามขั้นตอน

ในโปรแกรมจริง เปอร์เซ็นต์ของสีจะถูกแปลงเป็น

ค่า 0-255 และมี 1020 ขั้นตอน (255*4)

เพื่อหาว่าควรมีขั้นตอนใหญ่แค่ไหนระหว่างหนึ่ง up- หรือ

ขีดล่างของค่า LED ค่าใดค่าหนึ่ง เราเรียก CalculStep() ซึ่งคำนวณช่องว่างสัมบูรณ์ระหว่างค่าเริ่มต้นและค่าสิ้นสุด จากนั้นหารช่องว่างนั้นด้วย 1,020 เพื่อกำหนดขนาดของขั้นตอนระหว่างการปรับค่า */

int คำนวณขั้นตอน (int prevValue, int endValue) {

ขั้นตอน int = endValue - prevValue; // อะไรคือช่องว่างโดยรวม? if (step) { // ถ้าไม่ใช่ศูนย์ step = 1020 / step; // หารด้วย 1,020 } return step; }

/* ฟังก์ชันถัดไปคือ calcVal เมื่อค่าวนรอบ i, ถึงขนาดขั้นที่เหมาะสมสำหรับสีใดสีหนึ่ง จะเพิ่มหรือลดค่าของสีนั้นขึ้น 1 (R, G และ B คำนวณแยกกัน) */

int คำนวณVal (ขั้นตอน int, int val, int i) {

if ((ขั้นตอน) && i % step == 0) { // หากขั้นตอนไม่เป็นศูนย์และถึงเวลาเปลี่ยนค่า

if (ขั้นตอน > 0) { // เพิ่มค่าถ้าขั้นตอนเป็นบวก… val += 1; } else if (ขั้นตอนที่ 255) { val = 255; } else if (val < 0) { val = 0; } ค่าส่งคืน; }

/* crossFade() แปลงสีเปอร์เซ็นต์เป็น a

ช่วง 0-255 จากนั้นวนซ้ำ 1,020 ครั้ง ตรวจสอบว่าจำเป็นต้องอัปเดตค่าในแต่ละครั้งหรือไม่ จากนั้นจึงเขียนค่าสีไปยังหมุดที่ถูกต้อง */

เป็นโมฆะ crossFade (สี int ) { //改

// แปลงเป็น 0-255 int R = (สี[0] * 255) / 100; int G = (สี [1] * 255) / 100; int B = (สี[2] * 255) / 100; int Y = (สี[3] * 255) / 100; //改 int W = (สี[4] * 255) / 100; //改

int stepR = คำนวณขั้นตอน (prevR, R);

int stepG = คำนวณขั้นตอน (prevG, G); int stepB = คำนวณขั้นตอน (prevB, B); int stepY = คำนวณขั้นตอน (ก่อนหน้า, Y); //改 int stepW = คำนวณขั้นตอน (prevW, W); //改

สำหรับ (int i = 0; i <= 1,020; i++) { redVal = คำนวณVal (stepR, redVal, i); grnVal = คำนวณVal(stepG, grnVal, i); bluVal = คำนวณVal(stepB, bluVal, i); ylwVal = คำนวณVal(stepY, ylwVal, i); //改 whiVal = คำนวณVal(stepW, whiVal, i); //改

analogWrite (redPin, redVal); // เขียนค่าปัจจุบันไปยังพิน LED

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); analogWrite (ylwPin, ylwVal); //改 analogWrite(whiPin, whiVal); //改 analogWrite(grnPin2, grnVal); //改 analogWrite(bluPin2, bluVal); //改 analogWrite(ylwPin2, ylwVal); //改 analogWrite (redPin2, redVal); //改

ล่าช้า(รอ); // หยุดชั่วคราวสำหรับ 'รอ' มิลลิวินาทีก่อนที่จะทำการวนซ้ำ

if (DEBUG) { // หากเราต้องการเอาต์พุตแบบอนุกรม ให้พิมพ์ที่

if (i == 0 หรือ i % loopCount == 0) { // จุดเริ่มต้น และทุกๆ loopCount ครั้ง Serial.print ("Loop/RGBYW: #"); Serial.print(i); Serial.print(" | "); Serial.print (redVal); Serial.print(" / "); Serial.print(grnVal); Serial.print(" / "); Serial.println (bluVal); Serial.print(" / "); Serial.println (ylwVal); //改 Serial.print(" / "); //改 Serial.println(whiVal); //改 Serial.print(" / "); //改 } DEBUG += 1; } } // อัปเดตค่าปัจจุบันสำหรับลูปถัดไป prevR = redVal; ก่อนหน้า = grnVal; ก่อนหน้า = bluVal; ก่อนหน้า = ylwVal; //改 ก่อนหน้า = whiVal; //改 ล่าช้า(ถือ); // หยุดชั่วคราวสำหรับตัวเลือก 'รอ' มิลลิวินาทีก่อนที่จะทำการวนซ้ำ }

ขั้นตอนที่ 3: ตั้งค่า

1. รับเขียงหั่นขนม

2. การสาธิตการเชื่อมต่อสายไฟเพื่อให้ไฟ LED ส่องแสงได้:

   1. วาง LED บนเขียงหั่นขนม วางปลายด้านที่ยาวกว่าไว้ทางด้านซ้ายและด้านที่สั้นกว่าไว้ทางด้านขวา
   2. วางปลายสายจัมเปอร์ด้านหนึ่งบนจุดที่อยู่บนแถวเดียวกันโดยให้ปลายด้านที่ยาวกว่าของ LED วางปลายอีกด้านหนึ่งลงในส่วน Digital PWM รหัสระบุ LED สีเหลืองที่จะเชื่อมต่อกับ 10 และ 5, ไฟสีแดงถึง 6 และ 11, ไฟสีน้ำเงินถึง 8 และ 13, ไฟสีเขียวถึง 7 และ 12 และสุดท้าย LED สีขาวถึง 9
   3. วางปลายด้านหนึ่งของตัวต้านทานในแถวเดียวกันโดยให้ปลาย LED สั้นกว่า วางปลายอีกด้านหนึ่งไว้ใกล้ ๆ
   4. วางปลายสายจัมเปอร์อีกอันหนึ่งด้วยแถวเดียวกันโดยให้ปลายตัวต้านทานไม่อยู่ในแถวเดียวกันกับปลาย LED ที่สั้นกว่า วางปลายอีกด้านของลวดไว้ที่แถวประจุลบ
   5. วางปลายสายจัมเปอร์อีกเส้นหนึ่งบนแถวประจุลบ และวางปลายอีกด้านหนึ่งบน GND
3. ทำซ้ำขั้นตอนที่ 2 8 ครั้งตามที่คุณต้องการให้ไฟ LED 9 ดวงส่องแสง

4. วางเขียงหั่นขนมไว้ในกล่อง การช่วยเตือนบางอย่างที่นี่:

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