טיימר בשלט רחוק עם NodeMCU: 14 שלבים

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

כאן ניצור טיימר באמצעות NodeMCU ו- Adafruit. אנחנו הולכים להציג את הטיימר שלנו עם רצועת LED ונוכל לשלוט בו באמצעות הטלפון או המחשב שלנו!

המטרה שלנו:

צור טיימר באמצעות פס LED שנוכל: להתחיל, להשהות ולאפס באמצעות הטלפון או המחשב שלנו.

אספקה

חוּמרָה:

• NodeMCU ESP 8266
• רצועת LED NeoPixel של Adafruit

ספריות:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

אַחֵר:

חיבור WiFi הגון

שלב 1: בואו ליצור פיד ב- Adafruit

עכשיו, אחרי שקיבלנו את כל מה שאנחנו צריכים, אנחנו מוכנים להתחיל לבנות! קודם כל עלינו ליצור הזנה ב- Adafruit. Adafruit הוא שירות שמקל עלינו מאוד לחבר את הארדואינו שלנו לאינטרנט ולעשות תכונות שימושיות בשלט רחוק. אם עדיין לא עשית זאת, הירשם ל- Adafruit.

עכשיו בואו ניצור הזנה חדשה

אנחנו יכולים למנות את ההזנה שלנו לכל מה שאנחנו רוצים, אני קורא לזה 'טיימר'.

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

שלב 2: עכשיו בואו נכין לוח מחוונים

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

שלב 3: קבל את המפתח שלנו

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

תוכל לקבל את המפתח שלך על ידי לחיצה על כפתור מפתח AIO הצהוב בפינה השמאלית העליונה של המסך שלך ב- Adafruit.

שמור את המפתח הזה איפשהו, נזדקק לו אחר כך.

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

שלב 4: פתח את דוגמא לקריאת ההזנה

עכשיו בואו נפתח את IDE Arduino שלנו ונתחיל בתהליך הקידוד. קודם כל עלינו להתקין את ספריית Adafruit IO Arduino.

אינך יודע כיצד להתקין ספריות? זהו מדריך נהדר מאת Adafruit: Arduino Libraries

Adafruit מציעה הרבה דוגמאות שהוכנו מראש לשימוש וללמוד מהן. אחת הדוגמאות הללו היא: adafruitio_21_feed_read. תוכל למצוא דוגמה זו כאן: קובץ - דוגמאות Adafruit IO Arduino adafruitio_21_feed_read

(סליחה על הממשק ההולנדי שלי בתמונה)

שלב 5: בואו להגדיר את החיבור שלנו

אם פתחת בהצלחה את מערכון adafruitio_21_feed_read אתה אמור לראות 2 כרטיסיות במערכון שלך: adafruitio_21_feed_read ו- config.h. סקיצה זו בוצעה כך שנוכל להתחבר להזנה שהכנו בשלב 1.

כדי להתחבר להזנה הזו עלינו למלא מספר פרטים אודות ה- WiFi שלנו וחשבון Adafruit שלנו,

בואו ניסע אל config.h, כאן נמלא את הפרטים הבאים:

שם המשתמש שלך ב- Adafruit:

#הגדר IO_USERNAME "joopert"

מפתח Adafruit שלך:

#define IO_KEY "1234567890abcdefghijklmnop"

שם ה- WiFi שלך:

#הגדר WIFI_SSID "MyWifi"

וסיסמת ה- WiFi שלך:

#define WIFI_PASS "aVerySecretPassword"

כעת נחזור לכרטיסייה adafruitio_21_feed_read ונמלא:

שם המשתמש שלך ב- Adafruit … שוב:

#הגדר FEED_OWNER "joopert"

ולבסוף שם הפיד שלך (מהפיד שהכנו בשלב 1):

AdafruitIO_Feed *sharedFeed = io.feed ("טיימר", FEED_OWNER);

שלב 6: בדוק את החיבור ל- IA של Adafruit

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

Adafruit IO מחובר

אלה חדשות נהדרות! כעת נוכל להתחיל להוסיף פונקציונליות לטיימר שלנו …

שלב 7: מאפשר לד LED

עכשיו הגיע הזמן להדליק את רצועת הלד שלנו!

חבר את פס ה- LED שלך ל- PIN D5 (אם אינך מוצא את ה- D5 חבר אותו ל- PIN אחר ושנה את LED_PIN בקוד).

הגדר רצועת LED

הקוד הבא יוסיף את ספריית NeoPixel (למד עוד על ספרייה זו כאן: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) ויוודא שה- Arduino שלנו יודע היכן נמצאת רצועת ה- LED שלנו כמה אורות יש לו. אם לרצועת הלד שלך יש מפרטים שונים, שנה אותו בקוד.

הוסף את הקוד הבא מעל הגדרת הריק ():

// הגדר חיבור NeoPixel #כולל #ifdef _AVR_ #כלול #endif

#define LED_PIN D5 // לאן מחובר פס ה- LED?

#define LED_COUNT 30 // כמה פיקסלים יש לו?

#define BRIGHTNESS 50 // בהירות NeoPixel, 0 (דקות) עד 255 (מקסימום)

רצועת Adafruit_NeoPixel (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

הפעל רצועת LED

עכשיו נתחיל את רצועת הלד שלנו ונקבע את הבהירות (הבהירות נעה בין 0 דקות ל -255 מקסימום, אבל אני ממליץ על 50 … 255 בהיר ממש).

הוסף את הקוד הבא בהגדרת הריק ():

strip.begin (); // התחל אובייקט רצועת NeoPixel (חובה) strip.show (); // כבה את כל הפיקסלים בהקדם האפשרי strip.setBrightness (50); // הגדר את הבהירות לכ 1/5 (מקסימום = 255)

ledsOn (); // קורא לפונקציה להדליק כל נורית אחת אחת

תדליק את האורות

אולי כבר שמת לב שאנחנו קוראים לפונקציה שעדיין לא קיימת, וזה יהיה החלק הבא שלנו בקידוד. אם ברצוננו להדליק את האורות עלינו ליצור 'עבור לולאה' שמדליקה כל LED בודד אחד אחד (לא יודע מה זה לולאה עבור? בדוק את זה כאן: www.arduino.cc/reference/ en/שפה/מבנה/שליטה-מבנה/עבור/).

עכשיו אנחנו הולכים ליצור את הפונקציה: ledsOn ();

הוסף את הקוד הבא להלן void handleMessage ():

void ledsOn () {for (int i = 0; i <strip.numPixels (); i ++) {// לכל פיקסל ברצועה … strip.setPixelColor (i, 0, 0, 255); // הגדר את צבע הפיקסל ל- strip.show () כחול; // עדכן רצועה שתתאים}}

העלה

עכשיו הוא החלק המהנה, בואו נעלה את הקוד שלנו ל- NodeMCU … אם הכל עובד כמו שצריך, רצועת ה- LED שלכם צריכה להפוך לכחול לגמרי!

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

האם רק חלק מהפיקסלים אינם מופיעים?: בדוק אם הגדרת את כמות הפיקסלים הנכונה!

שלב 8: הוסף תזמון לטיימר

עכשיו אנחנו הולכים לוודא שהטיימר שלנו בעצם … ובכן … פעמים, משהו.

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

אם אתה מעוניין כיצד זה עובד אתה יכול לבדוק את המאמר הזה:

נוסיף את הקוד עבור מילי ():

שים את הקוד הזה מעל הגדרת הריק ()

unsign long long previousMillis = 0; // אחסן בפעם האחרונה שרצועת ה- LED עודכנה במרווח = 1000; // מרווח הטיימר שלנו (אלפיות השנייה)

ובואו נכניס את הקוד הזה ללולאת הריק ():

current Signillial millis = millis ();// התחל TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis;

// סוף RYTHM TIMER ****************************************** ***********

מה שעשינו זה עתה ליצור קצב לרצועה LED שלנו לכבות נוריות LED, בשלב הבא נוסיף את הקוד לשם כך.

שלב 9: ספירה לאחור

בשלב זה: נכין פונקציה שתוודא שבכל שנייה (או כל מרווח שהגדרתם) נכבה ONE LED בסוף הרצועה עד שכל הנורות שלנו יכבו.

ניצור למעלה 'int' שנקרא 'leds'. זה יגיד מאוחר יותר לטיימר שלנו כמה תאי LED עדיין יש לכבות אותו.

הוסף את הקוד הבא מעל הגדרת הריק ():

int leds = LED_COUNT-1; // מספר כמה פיקסלים צריך להדליק

כעת נוסיף את הפונקציה 'טיימר ();', פעולה זו תכבה אור כל שנייה

הוסף את הקוד הבא להלן ה- leeds void ():

טיימר חלל () {strip.setPixelColor (leds, 0, 0, 0);

אם (leds> -1) {leds--; } אחר {blinkie (); }}

אנו רוצים לתת משוב למשתמש כי הטיימר נעשה לאחר שכל האורות נשרפו. עם 'blinkie ();' הנורות יהבהבו אדום לאחר סיום הטיימר!

הוסף את הקוד הבא מעל הגדרת הריק ():

int blinkStatus = 1; // מספרת למצמץ (); לתפקד אם האור צריך להיות דולק או כבוי

הוסף את הקוד הבא להלן טיימר הריק ():

בטל מהבהב () {אם (blinkStatus == 1) {

blinkStatus = 0; strip.clear (); } אחר {blinkStatus = 1; for (int i = 0; i <strip.numPixels (); i ++) {// עבור כל פיקסל ברצועה … strip.setPixelColor (i, 255, 0, 0); // הגדר את צבע הפיקסל (ב- RAM) strip.show (); // עדכן רצועת התאמה}}}}

לבסוף עלינו לקרוא לפונקציה בלולאת הריק שלנו ();, זוכרים את TIMER RYTHM שהוספנו בשלב 8? בהצהרת if זו נקרא טיימר הפונקציות ();.

כעת TIMER RYTHM אמור להיראות כך:

// התחל TIMER RYTHM ****************************************** *********

אם (currentMillis - previousMillis> = מרווח) {previousMillis = currentMillis; שָׁעוֹן עֶצֶר(); strip.show ();} // סוף TIMER RYTHM ************************************* *******************

עכשיו תעלה את הקוד הזה!

כרגע רצועת ה- LED שלך אמורה לכבות נורית אחת בכל שנייה ולהבהב באדום בסיום …

עכשיו בואו להפוך את מאהב האם הזה לשליטה מרחוק!

שלב 10: הפוך אותו לשלט רחוק: חלק א '

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

עדיין פתחת את הכרטיסייה Adafruit שלך? בואו נחזור אל io.adafruit.com ובואו נלך ללוח המחוונים של ממשק הטיימר וניצור בלוק חדש: TOGGLE

1. חבר את המתג להזנת TIMER
2. הגדר את ערך ON ל: 1
3. הגדר את ערך OFF ל: 0

הסיבה לכך היא ש- Adafruit אינה שולחת נתוני טקסט ל- NodeMCU שלנו, אלא רק למספרים.

תוכל גם לתת למעבר את השם אם תרצה, אולי: 'מתג הפעלה/כיבוי'

עכשיו נחזור ל- Arduino IDE

רק כדי לוודא שהקוד שלנו מעודכן, בואו נעלה את הקוד שלנו שוב.

פתח את מוניטור הסידורים לאחר סיום ההעלאה והקש על ה- TOGGLE בלוח המחוונים של Adafruit כמה פעמים. כעת אנו אמורים לראות משהו כזה צץ במסך הטורי שלנו:

קיבל <- 0 קיבל <- 1 קיבל <- 0 קיבל <- קיבל 1 <- 0

המשמעות היא שאנו יכולים למעשה לשלוח פקדים ל- NodeMCU שלנו!

אם אינך מקבל הודעות אלה, בדוק אם נתוני Adafruit שלך ב- config.h עדיין נכונים.

שלב 11: הפוך אותו לשליטה מרחוק: חלק ב '

עכשיו נשאר רק לעשות משהו עם הפקדים שהתקבלו.

לשם כך עלינו לשנות את הצהרת ה- TIMER RYTHM if שלנו בלולאת הריק (); קצת.

אנו נגיד ל- NodeMCU שלנו כי עליו להתחיל את הטיימר רק לאחר שקיבלנו '1' (כלומר: ON) מ- Adafruit.

ראשית בואו נאסוף את הנתונים ש- Adafruit שולח לנו

הוסף את הקוד הבא מעל הגדרת הריק ():

int adaData; // אוספת את הנתונים ש- AdaFruit שולח לנו

עכשיו בואו למעשה לאסוף את הנתונים האלה

הוסף את הקוד הבא בתוך ידית ה- voidMessage ():

adaData = data-> toInt ();

בואו נשנה את לולאת החלל שלנו ();

כעת TIMER RYTHM אמור להיראות כך:

// התחל TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis; if (adaData == 0) {Serial.println ("אני לא רץ"); } אחרת אם (adaData == 1) {טיימר (); } strip.show (); } // סוף RYTHM TIMER ***************************************** *************

העלה את הקוד שלך …

עכשיו אתה אמור להיות מסוגל להדליק ולכבות את הטיימר באמצעות המתג ב- Adafruit!

שלב 12: שחק מסביב! סיימנו … או?

כרגע אתה צריך טיימר מרחוק מתפקד במלואו! אם זה בשבילך אז תודה שבאת עם הפרויקט הזה!

אם אתה רוצה להמשיך עוד קצת, בשלבים הבאים נוסיף כפתור איפוס לטיימר שלנו!

שלב 13: EXTRA: צור כפתור רגעי

נחזור ללוח המחוונים שלנו. כעת אנו רוצים ליצור שוב גוש חדש.

1. צור כפתור רגעי
2. חבר אותו להזנת 'טיימר'
3. הגדר את ערך העיתונות ל: 2
4. הסר את ערך השחרור
5. תנו לו צבע יפה!

לנוחיות הכפתור הרגעי כבר נקרא 'איפוס'!

לאחר שיצרת את הבלוק הזה בדוק אותו, הלחצן פועל אם אתה מקבל:

קיבלו <- 2

במסך הטורי שלך.

אם אינך רואה הודעה זו, נסה להעלות מחדש את הסקיצה

שלב 14: EXTRA: הוסף את פונקציית האיפוס

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

הוסף את הקוד הבא להלן מהבהב הריק ():

שידור חוזר () {leds = LED_COUNT; ledsOn (); }

עכשיו כל שנותר הוא לקרוא לתפקוד שלנו, לשם כך עלינו לשנות את TIMER RYTHM בפעם האחרונה

כעת TIMER RYTHM אמור להיראות כך:

// התחל TIMER RYTHM ****************************************** ********* if (currentMillis - previousMillis> = interval) {previousMillis = currentMillis if (adaData == 0) {Serial.println ("אני לא רץ"); } אחרת אם (adaData == 1) {טיימר (); } אחרת אם (adaData == 2) {שידור חוזר (); } strip.show (); } // סוף TIMER RYTHM ****************************************** *************

העלה את הקוד שלך …

עכשיו אתה אמור להיות מסוגל לאפס את הטיימר על ידי לחיצה על הכפתור!