שיפור קוביית מצב הרוח של Arduino LED (פשוטה) (כולל וידאו): 4 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:13

לאחר שראיתי פרויקט קוביות מצב רוח קטנות מסוג LED שנוצר על ידי 'ארל', החלטתי לעשות גרסה משופרת של קוביית ה- LED Mood Cube. הגרסה שלי תהיה מורכבת יותר מהמקורית, מכיוון שהיא תהיה מעט גדולה יותר מהמקורית, תהיה בעלת שני צבעים נוספים בהשוואה לקובייה המקורית (הוספת צהוב ולבן), בעלת כמות סיבוב אינסופית של צבעים וכו '. צריך להיות פרויקט טוב לתרגול על שימוש נוסף בנורות LED למי שהבין את הרעיון בחיבור נורות LED עם חוטים.

שלב 1: חומרים

להלן כמה חומרים שתצטרכו להכנת קוביית מצב הרוח הזו:

• לוח לחם
• ארדואינו - (יש לי לאונרדו כאן)
• ספק כוח Arduino / כבל USB
• לוח לחם
• חוטי מגשר (הרבה מהם, השתמשתי ב -29 חוטים)
• LED אדום x 2
• כחול LED x 2
• LED ירוק x 2
• LED צהוב x 2
• LED לבן x 1
• 9 נגדים
• קופסה גדולה מספיק כדי להתאים ללוח הלחם (השתמשתי בקופסת נעליים)
• סכין שירות
• עיתון

שלב 2: קוד

קצת הסבר לקוד שניתן כאן:

קרדיט הקודים מגיע למקור המקורי של הפרויקט שלי שכן עורך הפרויקט יצר את הקודים האלה. רק שיפרתי כמה מהם על ידי הפיכתם למורכבים יותר. בחלק מהקודים, ייתכן שתראה // 改 בסופו של דבר. המשמעות היא שהקוד הזה נערך על ידי, ולכן הוא שונה מהמקור המקורי שלי.

יש לי גם גרסה של הקוד על Arduino Creator.

/* קוד להצלחת 3 נוריות LED, אדום, ירוק וכחול (RGB) כדי ליצור דהייה, עליך לעשות שני דברים: 1. תאר את הצבעים שבהם ברצונך להציג. 2. רשום את הסדר בו ברצונך שהם ידהו.

תיאור צבע:

צבע הוא רק מערך של שלושה אחוזים, 0-100, השולט על הלדים האדומים, הירוקים והכחולים

אדום הוא הנורית האדומה כשהיא מלאה, כחולה וירוקה כבויה

int אדום = {100, 0, 0} הלבן העמום הוא שלושת הנורות ב- 30% int dimWhite = {30, 30, 30} וכו '.

כמה צבעים נפוצים מסופקים להלן, או צור בעצמך

רישום ההזמנה:

בחלק העיקרי של התוכנית, עליך לרשום את הסדר שבו ברצונך להציג צבעים, למשל. crossFade (אדום); crossFade (ירוק); crossFade (כחול);

הצבעים האלה יופיעו בסדר הזה, ודהו

בצבע אחד ולתוך הצבע הבא

בנוסף, ישנן 5 הגדרות אופציונליות שתוכל לשנות:

1. הצבע ההתחלתי מוגדר לשחור (כך שהצבע הראשון דוהה), אך ניתן להגדיר את הצבע ההתחלתי לכל צבע אחר 2. הלולאה הפנימית פועלת ל -1020 אינטראקציות; משתנה 'ההמתנה' קובע את משך הזמן המשוער של הצללה אחת. בתיאוריה, 'המתנה' של 10 אלפיות השנייה אמורה לבצע CrossFade של ~ 10 שניות. בפועל, שאר הפונקציות שהקוד מבצע להאט את זה עד ~ 11 שניות בלוח שלי. YMMV. 3. אם 'חזרה' מוגדרת ל- 0, התוכנית תעשה לולאה ללא הגבלת זמן. אם הוא מוגדר למספר, הוא יבצע לולאה של מספר הפעמים, ואז יעצור על הצבע האחרון ברצף. (הגדר 'החזרה' ל -1, והפוך את הצבע האחרון לשחור אם ברצונך שהוא ייעלם בסוף.) 4. יש משתנה אופציונלי 'החזק', אשר מעביר את התוכנית למשך 'אחזקה' באלפיות השנייה כאשר צבע הוא להשלים, אך לפני שהצבע הבא יתחיל. 5. הגדר את דגל DEBUG ל- 1 אם ברצונך שיישלח פלט באגים אל הצג הטורי.

הפנימיות של התוכנית אינן מסובכות, אבל הן

מעט קשוחים - הפעולות הפנימיות מוסברות מתחת ללולאה הראשית.

אפריל 2007, קליי שירקי

*

/ פלט

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 white [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int אדום [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 yellow [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int purple [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int orange [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int pink [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]; // 改

int wait = 15; // 10ms עיכוב פנימי של crossFade; עלייה לדהייה איטית // 改

int hold = 1; // החזקה אופציונלית כאשר הצבע הושלם, לפני ההצלבה הבאה // 改 int DEBUG = 1; // מונה DEBUG; אם הוא מוגדר ל -1, הוא יכתוב ערכים בחזרה באמצעות int serial loopCount = 60; // כל כמה זמן על DEBUG לדווח? int repeat = 0; // כמה פעמים עלינו לולאה לפני שעוצרים? (0 ללא עצירה) // 改 int j = 0; // מונה לולאה לחזרה

// אתחל משתני צבע

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; // 改

// הגדר את יציאות ה- LED

הגדרת void () {pinMode (redPin, OUTPUT); // מגדיר את הפינים כ- pinMode פלט (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

if (DEBUG) {// אם נרצה לראות ערכים לניפוי באגים …

Serial.begin (9600); // … הגדר את הפלט הסידורי}}

// תוכנית ראשית: רשום את סדר ההצללות

לולאת חלל () {crossFade (אדום); crossFade (ירוק); crossFade (כחול); crossFade (צהוב); crossFade (לבן); crossFade (ורוד); crossFade (סגול); crossFade (כתום);

אם (חזור) {// האם אנו עושים לולאה מספר סופי של פעמים?

j += 1; אם (j> = חזור) {// האם אנחנו עדיין שם? יציאה (j); // אם כן, עצור. }}}

/* להלן השורה היא הנקודה - לא תצטרך לשנות זאת ביסודות

התוכנית עובדת כך:

תארו לעצמכם הצללה המזיזה את הנורית האדומה מ- 0-10, הירוק מ- 0-5, והכחול מ -10 ל -7, בעשרה שלבים. נרצה לספור את 10 השלבים ולהגדיל או להקטין את ערכי הצבעים במרווחים אחידים. תארו לעצמכם a + מציין העלאת ערך ב- 1, ו- - שווה להורדתו. דהיית 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).

כדי להבין כמה גדול צריך להיות צעד אחד למעלה או למעלה

כלפי מטה של אחד מערכי ה- LED, אנו קוראים calcStep (), אשר מחשב את הפער המוחלט בין ערכי ההתחלה והסיום, ולאחר מכן מחלק את הפער ב- 1020 כדי לקבוע את גודל הצעד בין ההתאמות בערך. */

int calculStep (int prevValue, int endValue) {

int step = endValue - prevValue; // מה הפער הכולל? אם (שלב) {// אם הוא לא אפס, שלב = 1020 / שלב; // חלקו ב- 1020} שלב החזרה; }

/* הפונקציה הבאה היא calcalval. כאשר ערך הלולאה, i, מגיע לגודל המדרגה המתאים לאחד הצבעים, הוא מגדיל או מקטין את ערך הצבע הזה ב- 1. (R, G ו- B מחושבים כל אחד בנפרד.) */

int calcVal (int int, int val, int i) {

if ((שלב) && i % step == 0) {// אם השלב אינו אפס והגיע הזמן לשנות ערך, אם (שלב> 0) {// להגדיל את הערך אם השלב חיובי … val += 1; } אחרת אם (שלב 255) {val = 255; } אחרת אם (val <0) {val = 0; } val return; }

/* crossFade () ממיר את אחוז הצבעים ל-

טווח 0-255, ולאחר מכן לולאות 1020 פעמים, בודק אם צריך לעדכן את הערך בכל פעם, ואז לכתוב את ערכי הצבע לפינים הנכונים. */

void crossFade (int color ) {// 改

// המר ל- 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 = calcStep (prevR, R);

int stepG = calcStep (prevG, G); int stepB = calcStep (prevB, B); int stepY = calcStep (prevY, Y); // 改 int stepW = calcStep (prevW, W); // 改

for (int i = 0; i <= 1020; i ++) {redVal = calcVal (stepR, redVal, i); grnVal = calculateVal (stepG, grnVal, i); bluVal = calculateVal (stepB, bluVal, i); ylwVal = calculateVal (stepY, ylwVal, i); // 改 whiVal = calculateVal (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) {// begin, וכל 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; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 עיכוב (החזק); // השהה לאלפיות שנייה של 'המתן' לפני חידוש הלולאה}

שלב 3: הגדר

1. קבל את לוח הלחם.

2. הדגמה לחיבור חוטים כך שאור LED יכול לזרוח:

   1. שים את הנורית על לוח הלחם. מקם את הקצה הארוך יותר משמאל ואת הקצה הקצר יותר מימין.
   2. מקם קצה אחד של חוט מגשר במקום שנמצא באותה שורה עם הקצה הארוך יותר של הנורית. מקם את הקצה השני על קטע ה- PWM הדיגיטלי. הקוד ציין את נוריות הצהוב שצריך לחבר ל -10 ו -5, האדומות ל -6 ו -11, הכחולות ל -8 ו -13, הירוקות ל -7 ו -12 ולבסוף הנורות הלבנות ל- 9.
   3. מקם קצה אחד של הנגד באותה שורה עם הקצה הקצר יותר של הנורית. מקם את הקצה השני במקום קרוב.
   4. מקם קצה של חוט מגשר נוסף עם אותה שורה עם קצה הנגד שאינו באותה שורה עם הקצה הקצר יותר של הנורית. מקם את הקצה השני של החוט בשורת המטען השלילי.
   5. מקם קצה חוט מגשר נוסף בשורת המטען השלילי והנח את קצהו השני על GND.
3. חזור על שלב 2 במשך 8 פעמים כפי שאתה רוצה 9 נוריות לזרוח

4. מניחים את לוח הלוח בתוך הקופסה. כמה תזכורות כאן:

   1. השתמשתי באספקת חשמל. צור חור קטן עבור החוטים שלך באמצעות סכין כלי כדי לעבור דרך הקופסה ולהתחבר ללוח הלחם.
   2. וודא שהתיבה היא צד אחד פתוח. לארגז נעליים כבר יש צד אחד פתוח. אם הקופסה סגורה לגמרי, חותכים צד אחד של הקופסה כדי ליצור שטח פתוח.
   3. כסו את הצד בשום דבר בנייר. זה נועד לנורות LED לזרוח דרך הנייר.