חיסכון בחיי הסוללה בשינה עמוקה: 20 שלבים

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

האם אתה מעוניין להשתמש בסוללה עם ESP32 שלך? אם כן, אדון היום במידע טכני חשוב בנושא זה. אנו יודעים כי המיקרו -בקר הזה מוציא הרבה אנרגיה כאשר הוא מעביר מידע. הוא צורך כמעט 190 מיליאמפר. בסרטון זה אראה כיצד לחסוך באנרגיה מ- ESP32 בעזרת הפונקציה שנקראת "DEEP SLEEP". נגדיר את השבב להיכנס למצב זה, נלמד את הדרכים ליציאה ממצב זה וניצור דוגמה המציגה שלוש דרכים שונות להעיר את ESP32.

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

שלב 1: מבוא

ל- ESP32 יש מצב חיסכון בחשמל, הנקרא "שינה עמוקה". במצב זה, מעבדים, רוב זיכרון RAM וכל ציוד ההיקפי הדיגיטלי השעונים כבויים. החלקים היחידים של השבב שעדיין ניתנים לחיבור הם בקר ה- RTC, ציוד היקפי RTC (כולל מעבד ULP) וזיכרונות RTC.

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

שלב 2: דרכים להעיר את ESP32

ישנן חמש דרכים להעיר את ESP32:

• טיימר

• השכמה חיצונית (ext0)

• השכמה חיצונית (ext1)

• השכמה של מעבד עותק מסוג ULP

• לוח מגע

שלב 3: טיימר

לבקר RTC יש טיימר מובנה שניתן להשתמש בו להפעלת השבב לאחר פרק זמן מוגדר מראש. הזמן מצוין בדיוק במיקרו שניות.

esp_deep_sleep_enable_timer_wakeup (uint64_t time_in_us)

time_in_us> הוא הזמן במיקרו שניות

שלב 4: השכמה חיצונית (ext0)

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

esp_deep_sleep_enable_ext0_wakeup (gpio_num_t gpio_num, רמה int)

gpio_num> מספר GPIO משמש כמקור הפעלה. ניתן להשתמש רק ב- GPIO פונקציונלי RTC: 0, 2, 4, 12-15, 25-27, 32-39.

רמה> רמת קלט שתפעיל את האזעקה (0 = LOW, 1 = HIGH)

שלב 5: השכמה חיצונית (ext1)

בקר RTC מכיל היגיון להפעלת השעון המעורר באמצעות מספר RIO GPIOs.

esp_deep_sleep_enable_ext1_wakeup (uint64_t mask, esp_ext1_wakeup_mode_t mode)

mask> bit mask של מספרי GPIO שיגרמו להפעלה. ניתן להשתמש רק ב- GPIO התומכים ב- RTC במפת סיביות זו: 0, 2, 4, 12-15, 25-27, 32-39.

mode> בחר בפונקציית ההיגיון המשמשת לקביעת מצב ההפעלה:

• ESP_EXT1_WAKEUP_ALL_LOW: מתעורר כאשר כל ה- GPIO שנבחר נמצאים ב- LOW

• ESP_EXT1_WAKEUP_ANY_HIGH: מתעורר כאשר כל אחד ממערכות ה- GPIO שנבחרו הוא גבוה

שלב 6: ULP עיבוד עותקים

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

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

שלב 7: לוח מגע

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

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

// הגדר את לוח המגע כמקור השכמה esp_sleep_enable_touchpad_wakeup ();

שלב 8: כניסה למצב שינה עמוקה

לאחר הגדרת מצב השכמה, פקודה אחת להכניס את ESP32 למצב שינה עמוקה (הוצאה של 2.5 מיקרון או פחות) מספיקה. אני מדגיש כאן שההוצאה הזו היא משבב ה- ESP ולא מהצלחת, כיוון שהאחרון מוציא יותר.

esp_deep_sleep_start ();

מתוך פקודה זו, ESP32 נרדם ואינו מבצע את שורות הקוד הבאות למשל.

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

שלב 9: הנה עוד מידע חשוב

השיחה שלהלן מחזירה את הסיבה להתעוררות ESP32.

1: EXT0 2: EXT1 3: טיימר 4: TOUCHPAD 5: ULP

esp_sleep_get_wakeup_cause ();

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

esp_sleep_get_touchpad_wakeup_status ();

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

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

// RTC_DATA_ATTR aloca a variável on memorria RTCRTC_DATA_ATTR int bootCount = 0;

שלב 10: הפגנה

הסרטון מציג את התוכנית עובדת, בהתאם לתמונה.

שלב 11: WiFi NodeMCU-32S ESP-WROOM-32

שלב 12: הרכבה

שלב 13: תכנית

כעת נכין תוכנית שבה נגדיר את ה- ESP32 להיכנס למצב שינה עמוקה. הדבר יתעורר בשלוש דרכים שונות: אחת להתעוררות חיצונית (ext0), אחת עבור טיימר ואחת עבור לוח מגע. הם לא יכולים לעבוד יחד, לכן נשתמש במשתנה שיהווה מונה למספר הפעמים ש- ESP32 נתן ל- Boot להגדיר את הדרך להתעורר.

שלב 14: חובה לספרייה

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

ב- IDE של Arduino, עבור אל תפריט הסקיצה >> כלול ספרייה >> נהל ספריות….

שלב 15: ספריות ומשתנים

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

#include // biblioteca para control do display oled

// מבצע ליצירת שליטה לתצוגה // SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C תצוגה (SCL, SDA, U8X8_PIN_NONE); // RTC_DATA_ATTR aloca a variável na memoria RTC RTC_DATA_ATTR int bootCount = 0; // sensibilidade para aceitação do toque #define Threshold 40 // fator de conversão de microsegundos para segundos #define uS_TO_S_FACTOR 1000000 // tempo que o ESP32 ficará em modo sleep (em segundos) #define TIME_TO_SLEEP 3

שלב 16: התקנה

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

הגדרת void () {Serial.begin (115200); עיכוב (1000); // incrementa o numero de vezes que o BOOT ocorreu ++ bootCount; configureDisplay (); // chama a função para imprimir o motivo do BOOT print_wakeup_reason (); // se o numero de boot for PAR configuramos o ESP32 para despertar atreses do botão (EXT0) if (bootCount % 2 == 0) {esp_sleep_enable_ext0_wakeup (GPIO_NUM_39, 1); // 1 = גבוה, 0 = נמוך} // se עבור מספר רב של תצורות של ESP32 עבור despertar depois de um tempo definido אחרת אם (bootCount % 3 == 0) {esp_sleep_enable_timer_wakeup (TIME_TO_SLEEP * uS_TO_S_FACTOR); } // caso contrario configuramos os pinos de touch capacitivo para despertar o ESP32 else {// Interrupt setup על משטח מגע 5 (GPIO12) touchAttachInterrupt (T5, callback, Threshold); // הגדר את לוח המגע כמקור השכמה esp_sleep_enable_touchpad_wakeup (); } Serial.println ("entrando em modo sleep"); esp_deep_sleep_start (); // força o ESP32 entrar em modo SLEEP}

שלב 17: לולאה, התקשרות חזרה והגדרת תצוגה

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

// nada a se fazer no loopvoid loop () {} // callback das interrupções void callback () {// caso queira fazer algo ao ocorrer a interrupção} void configureDisplay () {// inicializa o display e configura alguns display parametros display. התחל(); display.setPowerSave (0); // modo powerSave (0-Off? 1-On) display.setFont (u8x8_font_torussansbold8_u); // fonte utilizada // imprime no display os numero de vezes que aconteceu o BOOT display.drawString (0, 0, "BOOT NUM:"); display.drawString (0, 2, String (bootCount).c_str ()); display.drawString (0, 4, "MOTIVO:"); }

שלב 18: Print_wakeup_reason (לדעת את הסיבה להתעוררות)

כאן, יש לנו את הפונקציה להדפיס את הסיבה להתעוררות ESP32. בדוק את הסיכה והדפס על המסך.

// função para imprimir a causa do ESP32 despertarvoid print_wakeup_reason () {esp_sleep_wakeup_cause_t wakeup_reason; סיבה מחרוזת = ""; wakeup_reason = esp_sleep_get_wakeup_cause (); // recupera a causa do despertar (wakeup_reason) {מקרה 1: סיבה = "EXT0 RTC_IO BTN"; לשבור; מקרה 2: סיבה = "EXT1 RTC_CNTL"; לשבור; מקרה 3: סיבה = "TIMER"; לשבור; מקרה 4: סיבה = "TOUCHPAD"; לשבור; מקרה 5: סיבה = "ULP PROGRAM"; לשבור; default: reason = "אין סיבה DS"; לשבור; } Serial.println (סיבה); display.clearLine (6); // apaga a linha 6 do display display.drawString (0, 6, reason.c_str ()); // imprime a causa do despertar no display // se despertou por TOUCHPAD, então vamos verificar em qual dos pinos ocorreu if (wakeup_reason == 4) {print_wakeup_touchpad (); // verifica o pino e imprime no display}}

שלב 19: Print_wakeup_touchpad (הכירו את ה- GPIO Touch)

כעת, בשלב זה, יש לנו את הפונקציה להדפיס את הסיכה שנגעה בה. שחזרנו את ה- GPIO שהעיר את ESP32 והדפסנו אותו על הצג.

// função para imprimir o pino que foi tocadovoid print_wakeup_touchpad () {touch_pad_t touchPin; touchPin = esp_sleep_get_touchpad_wakeup_status (); // recupera o GPIO que despertou o ESP32 String GPIO = ""; switch (touchPin) {case 0: GPIO = "4"; לשבור; מקרה 1: GPIO = "0"; לשבור; מקרה 2: GPIO = "2"; לשבור; מקרה 3: GPIO = "15"; לשבור; מקרה 4: GPIO = "13"; לשבור; מקרה 5: GPIO = "12"; לשבור; מקרה 6: GPIO = "14"; לשבור; מקרה 7: GPIO = "27"; לשבור; מקרה 8: GPIO = "33"; לשבור; מקרה 9: GPIO = "32"; לשבור; ברירת מחדל: Serial.println ("השכמה לא באמצעות משטח מגע"); לשבור; } Serial.println ("GPIO:"+GPIO); display.clearLine (7); // apaga a linha 7 do display display.drawString (0, 7, "GPIO:"); display.drawString (6, 7, GPIO.c_str ()); // כלא או GPIO}

שלב 20: הורד את הקבצים

PDF

INO