גשר נר מהבהב: 6 שלבים (עם תמונות)

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

מדריך זה מראה כיצד להפוך גשר נר פשוט עם אור סטטי לאור מצב רוח זוהר ויפה עם אינסוף וריאציות של אורות מהבהבים, מנצנצים, דפוסי גל ומה לא. קניתי ממכירות אחרי חג המולד גשר נרות תמורת 8 €. יש לו 7 נורות לד וכמה מתאם קיר של 33 וולט 3 וואט. הוא מאיר בצבע לבן בוהק וחם ויהיה מושלם לפרויקט הזה, שם אשים ארדואינו בכדי לגרום לנרות להבהב. הארדואינו הפופולרי ביותר הוא ה- Arduino Uno. בפרויקט זה אשתמש ב- Arduino Mega 2560.

אני עומד לזרוק את ספק הכוח 30 וולט ואשתמש בבנק כוח 5 וולט פשוט המיועד לטלפונים ניידים כאספקת החשמל.

דבר טוב לדעת על בנקים חשמליים הוא שיש להם מעגל פנימי, שהופך את הסוללה 3.7 V ל- 5 V. מכיוון שהתהליך משתמש בכוח כלשהו, בנק החשמל סוגר את עצמו, אם הוא אינו בשימוש. אם בנק החשמל משמש לגאדג'טים של DIY מבוססי Arduino, הגאדג'ט לא יכול להכניס את עצמו לשינה בחיסכון בחשמל ולהתחיל מחדש לאחר מספר דקות. זה יכבה את בנק החשמל. לגשר הנר המהבהב הזה אין מצב שינה. הוא משתמש בחשמל ללא הרף, ושומר על בנק החשמל פעיל, עד שכבל החשמל ינתק.

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

• 4 אורות מהבהבים שונים המחקים נרות אמיתיים
• 2 מנצנצים שונים (הבזקים אקראיים של אורות סטטיים אחרת)
• 2 דפוסי גל שונים
• אור סטטי פשוט

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

אספקה

• 1 גשר נרות לד עם 7 נורות. וודא שמדובר במתח DC נמוך, עם סוללות או עם מקור חשמל לתלייה הקיר, שהופך את 110 - 240 V AC הקטלני לכ- 6 - 30 V DC. אז זה לגמרי בטוח לפרוץ את גשר הנרות.
• 1 Arduino Mega (כל מיקרו -בקר אחר יעשה, רק וודא שאתה יכול לתכנת אותו)
• 1 לוח אב טיפוס
• חוטי מגשר וחוט אחר
• כלי הלחמה
• מולטימטר
• 7 נגדים, 120 Ω
• כפתור לחיצה אחד (אראה כיצד תוכל להשתמש בכפתור המובנה בארדואינו במקום זאת)
• טרנזיסטור IC של darlington עבור 7 טרנזיסטורים, ULN2803AP יעשה (אם אתה משתמש ב- Arduino Uno או Meaga, אתה לא באמת צריך את זה)
• בנק כוח של 5 וולט המיועד לטלפונים ניידים

שלב 1: בדוק מה יש לך

גלה באיזה מתח כל LED מפעיל וכמה זרם זורם.

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

הקריאות שלי

המתח מעל נר אחד (שלב 3): 3.1 וולט

שים לב שמקור החשמל לגשר הנרות היה 33 V. אז שבע פעמים 3.1 V הוא רק 21.7 V. על חלק מהנרות חייב להיות נגד נוסף. אילו מדדתי את מתח הנר הזה, זה בוודאי היה צריך להיות בערך 11 וולט.

הזרם זורם כאשר נרות דולקים (שלב 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 Ω אני עלול לפוצץ את הנורית. יש לי נגדים של 100 Ω ו- 120 Ω. אני הולך עם 120 Ω. זה נותן יותר הגנה.

בדיקת כל 7 הנרות עם 3 V העניקה אור בהיר, למעט נר אחד, שהיה בו רק אור עמום מאוד, כאשר רק 0.8 mA עברו. זה היה הנר שלי עם הנגד הנוסף. התברר שלנרות האחרים אין נגדים כלל. נורות הלד המשמשות בנברשת מיועדות פשוט ל -3 וולט! היה צריך לפתוח את הנר עם הנגד הנוסף באמצעות אלימות קלה, אבל שום דבר לא נשבר. הנגד נמצא ממש מתחת לנורית הזעירה הפנימית בתוך נורת הפלסטיק. הייתי צריך להסיר אותו ולהסיר את החוטים. זה היה קצת מבולגן, מכיוון שהלחם חימם קצת דבק חם, ששימש להרכבה.

אז עכשיו אני יודע שבכל מקור הכוח שבו אני משתמש, לא משנה מה המתח, אני חייב להוריד את המתח ל -3 V כדי לאפשר 19 mA לעבור.

אם הייתי מכיר יותר את טכנולוגיית ה- LED, הייתי מזהה את סוג ה- LED המשמש והייתי יודע שהוא צריך 3 וולט.

שלב 2: קצת הלחמה

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

גשר הנר צריך 8 כבלים כדי לעבור בין הארדואינו לגשר. אם אתה מוצא כבל עם 8 חוטים מבודדים, זה יהיה נהדר. חוט אחד חייב להכיל 120 mA, השאר נושאים 20 mA לכל היותר. בחרתי להשתמש ב -4 כבל חוט כפול, שהיה לי במקרה.

התמונה הראשונה מראה כיצד הכנתי חוט משותף אחד לחיבור כל חוטי ה'+'מהנרות. הפשיטו מעט בידוד של החוט המשותף לכל נר. הוסף חתיכת צינור בידוד לכווץ (הרצועה הצהובה בתמונה) לכל מפרק והנח אותו במקום הנכון של הכבל המשותף. הלחם את חוט ה '+' מכל נר למפרק שלו, כסה את המפרק בעזרת צינור הצטמקות והכווץ אותו. כמובן שגם סרט דבק פשוט בסדר, הכל יכוסה בסופו של דבר.

התמונה השנייה מציגה את חוטי ה--'שכל נר צריך. חוט ה'+'המשותף עובר ישירות לסיכה 5V של הארדואינו (או אולי דרך לוח הלחם). כל חוט '-' עובר לסיכה משלו של הטרנזיסטור IC (שוב, כנראה דרך לוח הלחם).

Arduino נקרא לעתים קרובות לוח אב טיפוס. לוח לחם הוא גם משהו שאתה משתמש בו באב טיפוס. מה שאני מתאר במדריך זה הוא אב טיפוס. אני לא אפתח אותו למוצר מבריק יוקרתי עם הכל מוסתר במארזי פלסטיק נחמדים. לקחת אותו מאב הטיפוס לשלב הבא פירושו החלפת לוח הלוח במעגל מודפס ורכיבים מולחמים ואפילו החלפת הארדואינו בשבב מיקרו -בקר פשוט (למעשה שבב כזה הוא המוח של הארדואינו). והכל מתאים למארז פלסטיק או בתוך גשר הנרות שנפרץ.

שלב 3: החיבורים

אודות Arduinos, נלקח מדף זה:

• סה"כ זרם מקסימלי לכל פין קלט/פלט: 40mA
• סכום הזרמים מכל סיכות הכניסה/הפלט המשולבות: 200mA

הנרות שלי שואבים 19 mA כל אחד, כשהם מופעלים על ידי 3 V. ישנם שבעה מהם, מה שהופך 133 mA. אז אוכל להפעיל אותם ישירות מסיכות הפלט. עם זאת, יש לי כמה מחשבי IC טרנזיסטור דארלינגטון חילוף. אז חשבתי, למה לא. המעגל שלי עושה את הדבר בצורה הנכונה: סיכות נתונים מיועדות רק לאותות, לא לעוצמה. במקום זאת אני משתמש בסיכת 5 V בארדואינו להפעלת נורות ה- LED. בעת הפעלת המבחן, יש לי את המחשב הנייד שלי מחובר ל- Arduino. הכל מופעל באמצעות ה- USB למחשב הנייד, המעניק 5 V. ל- Arduino Mega יש נתיך משלו, שנושב במהירות של 500 mA כדי להגן על המחשב. הנרות שלי מושכים לכל היותר 133 mA. הארדואינו כנראה הרבה פחות. הכל פועל כשורה, כאשר הוא מופעל על ידי המחשב הנייד, כך ששימוש בחבילת סוללה של 5 V המחובר ליציאת ה- USB של הארדואינו הוא בסדר גמור.

סיכות הנתונים D3 - D9 עוברות ל- IC ULN2803APGCN. הנורות פועלות על 3 וולט. כל נורה מחוברת למקור ה -5 וולט ובהמשך לנגד 120 Ω. בהמשך לערוץ אחד של ה- IC, המחבר לבסוף את המעגל לקרקע באמצעות טרנזיסטור darlington ב- IC.

כפתור לחיצה נוסף למעגל כדי לאפשר פעולת משתמש כלשהי. לפיכך, לגשר הנרות יכולות להיות כמה תוכנות לבחירה על ידי משתמשים.

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

התמונות מראות כיצד הכבלים החדשים יוצאים מהגשר, כיצד הנחתי את ה- IC הטרנזיסטור והנגדים על לוח הלחם וכיצד חוטי המגשר מתחברים ל- Arduino Mega. חתכתי 4 חוטי מגשר זכר-זכר ל -8 חוטים חצי, אותם הלחמתי ל -8 הכבלים היוצאים מגשר הנרות. בדרך זו אני יכול פשוט לתקוע את הכבלים לתוך לוח הלחם.

חלופה ללא טרנזיסטורים

בשלב הקודם הכנתי חוט '+' משותף לנרות וחוטים נפרדים '-', העוברים דרך הטרנזיסטור IC לקרקע. כאשר סיכת נתונים אחת עולה גבוה, החוט '-' המתאים מקבל מקורקע דרך הטרנזיסטור שלו ונורות ה- LED.

חיבור חוטי ה--ישירות לסיכות הנתונים של הארדואינו יעבוד גם כן, אך תמיד חשוב שתדע כמה זרמי הנתונים יכולים לעמוד! גישה זו תדרוש שינוי בתוכנית שלי. זה היה צריך את סיכות הנתונים כדי לרדת כדי להדליק את הנרות. כדי להשתמש בתוכנית שלי כפי שהיא, עליך להחליף '+' ו- '-' בנרות. יש חוט '-' משותף לנרות, שעובר ל- GND על הארדואינו. והחוטים הנפרדים עוברים בין חוט ה '+' של הנר לבין סיכת נתונים של הארדואינו.

שלב 4: תוכניות האור

התוכנית שלי, אותה אני מציג בשלב הבא, עוברת על 9 תוכניות אור. לחיצה על הכפתור תשחרר את האורות לשנייה, ואז תתחיל תוכנית התאורה הבאה. התוכניות הן כדלקמן:

1. הבהוב חזק. הנרות מהבהבים באופן אקראי. זה נראה מאוד מעצבן כשאתה בוהה בהם ממרחק קרוב, אבל עשוי להיראות טוב מרחוק ואולי מאחורי חלון עליית גג קפוא. אם כי, השכן שלך עשוי לקרוא למכבי האש.
2. הבהוב רך. נראה מאוד טוב. כמו נרות אמיתיים בחדר ללא טיוטה.
3. הבהוב משתנה. הנרות מתחלפים בצורה חלקה בין הבהובים חזקים ורכים במרווחים של כ -30 שניות.
4. הבהוב משתנה. כמו מס '3, אבל כל נר משתנה בקצב שלו בין 30 ל -60 שניות.
5. נצנוץ מהיר. הנרות מאירים ברמה מעומעמת סטטית ומנצנצים באופן אקראי. בממוצע יש נצנוץ אחד בכל שנייה.
6. נצנוץ איטי. כמו מספר 5, אבל בקצב איטי בהרבה.
7. גל מהיר מהנר העליון האמצעי אל התחתונים.
8. גל איטי מהנר העליון האמצעי אל התחתונים.
9. אור בהיר סטטי. הייתי צריך לכלול את זה, לא רציתי להיפטר מהפונקציה המקורית.

שלב 5: הקוד

/*

BRIDGE CAMLE BRIDGE */ // הכריז על משתנה המצב להחזיק את המצב // באמצעות פעולת איפוס _attribute _ ((סעיף (". Noinit"))) מצב int ללא סימן; // כאשר התוכנית מתחילה לאחר איפוס, פיסת זיכרון זו אינה מאתחלת, אך היא מחזיקה בערך // שהיה לה לפני האיפוס. בפעם הראשונה שבה התוכנית // מופעלת, היא מחזיקה ערך אקראי. / * * שיעור הנרות מכיל את כל הדרוש * לחישוב רמת האור עבור * נר מהבהב. */ נר בכיתה {פרטי: זמן מיקס ארוך; זמן ארוך; מקסלייט ארוך; minlite ארוך; ממוצע ארוך; זמן origmaxtime ארוך; זמן מקורי ארוך; אוריגמקסליט ארוך; אוריגמינליט ארוך; origmeanlite ארוך; זמן deltamaxtime; זמן דלתא ארוך; דלתמקסליט ארוך; deltaminlite ארוך; דלתאמאנליט ארוך; lforate ארוך; ארוכה ארוכה; התחלה ארוכה; מטרה ארוכה; פקטור צף; זמן יעד ארוך; זמן התחלה ארוך; זמן deltat ארוך; יעד חדש (חלל) חלל; יעד אחד ארוך (ריק); ציבורי: נר (מחצלת ארוכה, מיטה ארוכה, ארוכה מל, ארוכה מיל, ארוכה מל, ארוכה); רמה ארוכה עכשיו (חלל); initlfo חלל (deltamat ארוך, deltamit ארוך, deltamal ארוך, deltamil ארוך, deltamean ארוך, קצב ארוך); void setlfo (void); }; נר:: נר (מזרן ארוך, ארוך מיט, ארוך מל, ארוך מיל, ארוך מל, ארוך eo): maxtime (מחצלת), מינימום (מיט), maxlite (mal), minlite (mil), meanlite (mel), evenout (eo), origmaxtime (mat), origmintime (mit), origmaxlite (mal), origminlite (mil), origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () מחזירה את רמת האור שהנר צריך להיות כרגע. * הפונקציה דואגת להגדיר רמת אור אקראית חדשה ואת * הזמן שצריך לקחת עד להגיע לרמה זו. השינוי אינו לינארי, * אך עוקב אחר עקומה סיגמואית. כאשר לא הגיע הזמן להגדיר רמה חדשה *, הפונקציה פשוט מחזירה את רמת האור. */ נר ארוך:: levelnow (void) {עזרה ארוכה, עכשיו; צף t1, t2; עכשיו = מיליס (); אם (עכשיו> = Targettime) {help = target; newtarget (); עזרה חזרה; } אחר {// עזרה = יעד * (מילי () - זמן התחלה) / deltatime + התחלה * (targettime - millis ()) / deltatime; t1 = float (targettime - now) / deltatime; t2 = 1. - t1; // זוהי עזרה לחישוב הסיגמואיד = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; עזרה חזרה; }} נר חלל:: newtarget (void) {סכום ארוך; סכום = 0; עבור (long i = 0; i <evenout; i ++) sum+= onetarget (); התחל = יעד; target = sum / evenout; זמן התחלה = מיליס (); targettime = זמן התחלה + אקראי (מינימום, זמן מיקס); deltatime = Targettime - זמן התחלה; } נר ארוך:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * האלגו לניצוץ "לאחר אלפיות השנייה": * התחל לבדוק אחרי קצב / 2 אלפיות השנייה * במהלך תקופה של קצב / 2 אלפיות השנייה, עשה * את הסיכוי לנצוץ להיות 50 %. * אם הקצב הוא 10000 ms, במהלך 5000 ms המטבע * הופך 50 פעמים. * 1/50 = 0.02 * אם אקראית (10000) התחלה + שיעור / 2) {אם (אקראית (שיעור) יעד החזרה) lowlite; return (start - lowlite) * (Targettime - עכשיו) / (Targettime - Starttime) + lowlite; } twinkler void:: twink (void) {starttime = millis (); Targettime = אקראי (מינימום, זמן מיקס) + זמן התחלה; התחל = אקראי (minlite, maxlite); } void setup () {int led; // קראו את משתנה מצב הקסם, שאמור לספר // איזו תוכנית אור שהופעלה בפעם הקודמת, הגדילו אותה // ואפסו לאפס אם הצפה. מצב ++; מצב %= 9; // זה מטפל בכל ערך שהוא // הייתה הפעם הראשונה שהארדואינו // הפעיל את התוכנית הזו. / * * הערה חשובה * =============== * * הדבר החיוני שתוכנית זו עושה הוא להוציא אותות PWM * לנורות LED. כאן הגדרתי את הפינים 3 עד 9 למצב פלט *. ב- Arduino Mega2560, סיכות אלה מפלטות * אותות PWM יפה. אם יש לך ארדואינו אחר, בדוק * באילו סיכות (וכמה) תוכל להשתמש. אתה תמיד יכול * לשכתב את הקוד לשימוש בתוכנת PWM, אם ה- Arduino שלך * לא יכול לספק מספיק סיכות PWM לחומרה. * */ pinMode (3, OUTPUT); pinMode (4, OUTPUT); pinMode (5, OUTPUT); pinMode (6, OUTPUT); pinMode (7, OUTPUT); pinMode (8, OUTPUT); pinMode (9, OUTPUT); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // פשוט כבה את הנורית האדומה המעצבנת על הנר ארדואינו * *[7]; // התכונן להשתמש בנרות המהבהבים, בין אם אתה משתמש בהם ובין אם לא מנצנץ *מנצנץ [7]; // התכונן להשתמש בנרות המנצנצים … אם (mode == 8) {עבור (int i = 3; i <10; i ++) analogWrite (i, 255); בעוד (נכון); // בכל פעם שתוכנית זו מופעלת, היא נכנסת ל // לולאה אינסופית מסוג זה, עד ללחיצה על כפתור האיפוס //. } אם (מצב <2) // מהבהב {זמן רב _; זמן ארוך_; maxlite_ ארוך; minlite_ ארוך; meanlite_ ארוך; ארוך אפילו_; אם (mode == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; even_ = 1; } אם (mode == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; even_ = 1; } עבור (int i = 0; i <7; i ++) {יכול = נר חדש (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // הלולאה האינסופית לנרות מהבהבים {for (int i = 0; i levelnow ()); }} אם (מצב <4) // lfo נוסף להבהוב {if (mode == 2) // אותו lfo (30 שניות) לכל הנרות {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // משתנה lfo: s לנרות {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); יכול [1]-> initlfo (75, 50, 0, 50, 36, 25000); יכול [2]-> initlfo (75, 50, 0, 50, 36, 30000); יכול [3]-> initlfo (75, 50, 0, 50, 36, 35000); יכול [4]-> initlfo (75, 40, 0, 50, 36, 40000); יכול [5]-> initlfo (75, 30, 0, 50, 26, 45000); יכול [6]-> initlfo (75, 20, 0, 50, 16, 50000); יכול [7]-> initlfo (75, 10, 0, 50, 6, 55000);} בעוד (true) // הלולאה האינסופית לנרות מהבהבים עם lfo {long lastclock = 0; for (int i = 0; i levelnow ()); if (millis ()> lastclock + 4000) {lastclock = millis (); עבור (int i = 0; i setlfo ();}}} אם (מצב <6) // נרות מנצנצים {int speedo; if (mode == 4) speedo = 6000; אחרת speedo = 22000; עבור (int i = 0; i <7; i ++) twink = מנצנץ חדש (300, 295, 255, 250, speedo); בעוד (true) {for (int i = 0; i levelnow ()); } } // גלים. // קטע זה מתחיל בסוגריים מתולתלים רק // כדי להבטיח שאין שמות משתנים סותרים. // אין צורך בסוגריים אחרים, אין צורך לבדוק // את ערך המצב.{int lolite = 2; int hilite = 255; int מתכוון; int ampl; לצוף fasedelta = 2.5; שלב צף; int elong; פקטור צף; תקופה ארוכה; ממוצע = (lolite + hilite) / 2; ampl = hilite - ממוצע; אם (מצב == 6) תקופה = 1500; תקופה אחרת = 3500; פקטור = 6.28318530718 / תקופה; בעוד (נכון) {שלב = פקטור * (מילי (%) תקופה); elong = ממוצע + ampl * sin (שלב); analogWrite (7, מוארך); analogWrite (9, מוארך); שלב = פקטור * ((מילי () + נקודה / 4) תקופה); elong = ממוצע + ampl * sin (שלב); analogWrite (3, מוארך); analogWrite (8, מוארך); שלב = פקטור * ((מילי () + נקודה / 2) תקופה); elong = ממוצע + ampl * sin (שלב); analogWrite (4, מוארך); analogWrite (5, מוארך); שלב = פקטור * ((מילי () + 3 * נקודה / 4) תקופה); elong = ממוצע + ampl * sin (שלב); analogWrite (6, מוארך); } // בעת חיבור חוטי הנר לארדואינו, // ערבבתי אותם ומעולם לא סידרתי אותם. // הסדר חשוב ליצירת דפוסי גל, // אז פשוט כתבתי לי את הטבלה הקטנה הזו: // // נר# בגשר: 2 3 5 4 7 6 1 // סיכת נתונים על Arduino: 3 4 5 6 7 8 9}} לולאת void () {// מכיוון שכל תוכנית אור היא לולאה אינסופית משלה, // כתבתי את כל הלולאות בקטע begin () // ולא השארתי דבר עבור החלק הזה של לולאה (). }

שלב 6: אודות PWM

הנורות זוהרות בהירות כאשר הן מופעלות עם 3 וולט. באמצעות 1.5 V בלבד הן אינן נדלקות כלל. נורות LED אינן דוהות יפה עם המתח הדועך, כמו שעושים נורות ליבון. במקום זאת יש להפעיל אותם במתח מלא ואז לכבות אותם. כשזה קורה 50 פעמים בשנייה, הם מאירים יפה עם בהירות של 50 %, פחות או יותר. אם יורשו להם להיות ב- 5 ms בלבד וב- 15 ms, הם עשויים לזרוח עם בהירות של 25 %. טכניקה זו היא מה שהופך את אור LED לעמעם. טכניקה זו נקראת אפנון רוחב הדופק או PWM. לבקר מיקרו כמו Arduino יש בדרך כלל סיכות נתונים שיכולות לשלוח אותות הפעלה/כיבוי. לחלק מסיכות הנתונים יש יכולות מובנות ל- PWM. אך אם אין מספיק סיכות עם PWM מובנה, בדרך כלל ניתן להשתמש בספריות תכנות ייעודיות ליצירת "סיכות PWM לתוכנה".

בפרויקט שלי השתמשתי ב- Arduino Mega2560, בעל PWM חומרה בפינים 3 - 9. אם אתה משתמש ב- UNO Arduino, יש לך רק שישה סיכות PWM. במקרה כזה, אם אתה צריך נר ז '(או אפילו יותר), אני יכול להמליץ על ספריית ה- PWM של תוכנת ברט האגמן, שתוכל למצוא כאן.