מצב פעיל Esp32 וצריכת חשמל במצב שינה עמוקה

ESP32 הוא אחד ממודולי המיקרו-בקרים המבוססים על Wi-Fi הפופולריים ביותר והוא בחירה פופולרית ביישומי IoT ניידים רבים. זהו בקר חזק שתומך בתכנות ליבה כפולה ויש לו גם תמיכה מובנית ב- Bluetooth עם אנרגיה נמוכה (BLE), מה שהופך אותו לבחירה טובה עבור יישומים ניידים כמו במכשירי iBeacon, GPS Trackers וכו '. עם זאת, ביישומים המופעלים באמצעות סוללה כמו אלה., החשש העיקרי הוא גיבוי הסוללה. ניתן להגדיל את גיבוי הסוללה על ידי שליטה חכמה יותר על יחידת המיקרו-בקר כמו שאפשר לתכנת את ESP32 במצב שינה במצב האידיאלי להגדלת גיבוי הסוללה של המכשיר.

בפרויקט זה נבדוק את הצריכה הנוכחית של יחידת המיקרו-בקרה ESP32 הפופולרית ביותר באמצעות Wi-Fi ו- Bluetooth, במצב עבודה רגיל ובמצב שינה עמוק. כמו כן, נבדוק את ההבדל ונבדוק כיצד להכניס את ה- ESP32 למצב שינה עמוק. תוכלו גם לבדוק את המאמר כיצד למזער את צריכת החשמל במיקרו-בקרים לקבלת טיפים אחרים שניתן להשתמש בהם בכדי להפוך את העיצוב שלכם להרבה יותר חסכוני בחשמל. יתר על כן, אם אתה מעוניין במצב שינה של מיקרו-בקרים אחרים, תוכל לבדוק את מצב השינה של Arduino ואת מצב השינה ESP8266 NodeMCU גם כן.

דרישות

לשם כך, נשתמש ב- Devkit V4.0 מבוסס ESP32 מ- Espressif שיש לו USB ל- UART כמו גם בפינאוטים אחרים של ESP32 לחיבור קל. התכנות יבוצע עם Arduino IDE. אם אתה חדש לגמרי, אז בתחילת העבודה עם ESP32 באמצעות Arduino, קרא את המאמר המקושר לפני שתמשיך.

הדרישות של פרויקט זה הן:

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

לכן, נדרשים רכיבים נוספים-

LED - 1 יח '
לחצן כפתור (מתג מישוש) - 2 יח '
נגדי 4.7k - 2 יח '
נגד 680R - 1 יח '
קרש לחם
חבר חוט
מתאם 5V או יחידת אספקת חשמל
כבל מיקרו USB
Arduino IDE עם ממשק תכנות ESP32 במחשב נייד או מחשב נייד.

תרשים מעגלים של מצב שינה במצב ESP32

סכמטי ההרדמה של ESP32 עם לחצן הלחיצה מוצג להלן.

הסכימטי הוא די פשוט. יש לו שני כפתורים. כפתור השינה יכניס את ה- ESP32 למצב שינה עמוק ומתג אחר משמש להעיר את ה- ESP32 ממצב שינה. שני הכפתורים מחוברים ב- PIN 16 וב- PIN 33. שני הכפתורים מוגדרים כפעילים נמוכים בלחיצה עליהם, ולכן ניתן משיכה נוספת. עם זאת, כדי לזהות אם ה- ESP 32 נמצא במצב שינה או במצב מצב רגיל, LED מחובר ל- IO Pin 4.

סקירה כללית של מצבי שינה ב- ESP32

ישנם מצבי עוצמה רבים ושונים עבור ESP32, כלומר מצב פעיל, מצב שינה במודם, מצב שינה קל, מצב שינה עמוק ומצב שינה.

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

חוּמרָה	מצב פעיל	מצב שינה-מודם	מצב שינה קל	מצב שינה עמוק	תַרְדֵמָה
מעבד	עַל	עַל	הַפסָקָה	כבוי	כבוי
WiFi / BT	עַל	כבוי	כבוי	כבוי	כבוי
ציוד היקפי RTC ו- RTC	עַל	עַל	עַל	עַל	כבוי
מעבד ULP-Co	עַל	עַל	עַל	דולק כבוי	כבוי

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

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

תכנות ESP32 למצב שינה עמוקה

את התוכנית המלאה תוכלו למצוא בתחתית עמוד זה. הוא נכתב עבור Arduino IDE וניתן להתאים אותו בקלות לדרישותיך. ההסבר לקוד הוא כדלקמן.

בתחילת הקוד, // צור משתנה PushButton PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // הגדר Led Pin uint8_t led_pin = GPIO_NUM_4; // הגדר סיכת השכמה uint8_t wakeUp_pin = GPIO_NUM_33;

שלושת השורות שלעיל מגדירות את סיכת ההשכמה, סיכת LED וסיכת מצב שינה.

בטל התקנה () { // שים את קוד ההתקנה שלך כאן, להפעלה פעם אחת: // הגדר את היציאה הטורית על 115200 Serial.begin (115200); עיכוב (1000); // הגדר את סיכת ה- PushButton כקלט עם PinUp פנימי של PullUp (pushBtn.pin, INPUT_PULLUP); // הגדר את המטפל ב- Interrupt עם סיכת הלחצן במצב Falling attachInterrupt (pushBtn.pin, isr_handle, FALLING); // הגדר את פין ה- Led כ- pinupMode (led_pin, OUTPUT); // צור משימה שתבוצע בפונקציה blinkLed (), עם עדיפות 1 ותבוצע בליבה 0 xTaskCreate ( blinkLed, / * פונקציית משימה. * / "blinkLed", / * שם המשימה. * / 1024 * 2, / * גודל הערימה של המשימה * / NULL, / * הפרמטר של המשימה * / 5, / * עדיפות המשימה * / & taskBlinkled); / * ידית משימות כדי לעקוב אחר המשימה שנוצרה * / עיכוב (500); // הגדר את פין 33 כמקור התעוררות ext0 עם רמת לוגיקה נמוכה esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }

באמור לעיל, הפרעה מוגדרת למצב נופל על ידי קטע הקוד

attachInterrupt (pushBtn.pin, isr_handle, FALLING);

לכן, בכל פעם שלוחצים על המתג, רמת הלוגיקה תשתנה מלוגיקה 1 (3.3V) ללוגיקה 0 (0V). המתח של סיכת הכפתור ייפול וה- ESP32 יזהה שלוחצים על המתג. יש גם משימה שנוצרה כדי להבהב את ה- LED.

xTaskCreate ( blinkLed, / * פונקציית משימה. * / "blinkLed", / * שם המשימה. * / 1024 * 2, / * גודל הערימה של המשימה * / NULL, / * פרמטר המשימה * / 5, / * עדיפות של המשימה * / & taskBlinkled); / * ידית משימות כדי לעקוב אחר המשימה שנוצרה * / עיכוב (500);

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

esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);

לאחר מכן, תוך כדי לולאה-

void loop () { // שים את הקוד הראשי שלך כאן, כדי לרוץ שוב ושוב: אם (pushBtn.pressed) { Serial.printf ("PushButton (% d) לחצו \ n", pushBtn.pin); Serial.printf ("השעיית משימת 'blinkLed' \ n"); // השהה את blinkLed Task vTaskSuspend (taskBlinkled); digitalWrite (led_pin, LOW); Serial.printf ("הולך לישון….. \ n", pushBtn.pin); pushBtn.pressed = false; // עבור לישון עכשיו esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); מתג (wakeupReason) { מקרה ESP_SLEEP_WAKEUP_EXT0: Serial.println ("באמצעות אות חיצוני ext0 עבור WakeUp משינה"); לשבור; מקרה ESP_SLEEP_WAKEUP_EXT1: Serial.println ("באמצעות ext1 אות חיצוני עבור WakeUp משינה"); לשבור; מקרה ESP_SLEEP_WAKEUP_TIMER: Serial.println ("באמצעות אות טיימר עבור WakeUp מתוך שינה"); לשבור; מקרה ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("באמצעות אות TouchPad עבור WakeUp משינה"); לשבור; מקרה ESP_SLEEP_WAKEUP_ULP: Serial.println ("באמצעות אות ULP עבור WakeUp מתוך שינה"); לשבור; ברירת מחדל: הפסקה; Serial.printf ("המשך משימת 'blinkLed' \ n"); // הפעל מחדש את משימת blinkLed vTaskResume (taskBlinkled); } }

זמן הלולאה בודק כל הזמן אם לחצן השינה נלחץ או לא. אם לוחצים על הלחצן, הוא יפסיק או ישעה את משימת ההבהוב של ה- LED ויפעיל את פונקציית התחלת שינה עמוקה במיוחד -

esp_deep_sleep_start ();

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

לבסוף, ניתן לראות את פונקציית ההבהוב של ה- LED בתמציות הבאות, היא תמצמצ את נורית ה- LED שניות שניות.

void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // החלף את ערך הסיכה pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * פשוט החלף את ה- LED כל 1000ms או 1 שניה * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }

בדיקת ESP32 במצב שינה עמוקה

המעגל בנוי בלוח לחם ומולטימטר מהדורת מטרבי XB משמש למדידת הזרם. הזרם הנמשך על ידי המעגל במצב פעיל הוא כמעט 58 mA אך במצב שינה עמוק, הזרם הוא כמעט 4.10 mA. בתמונה למטה מוצגת צריכת הזרם במצב פעיל ESP32 -

במצב שינה עמוקה, הצריכה הנוכחית נרשמת ירדה לסביבות 3.95mA, התמונה למטה מציגה את צריכת הזרם במצב שינה עמוק ESP32-

</s> </s> </s> </s> </s> </s> </s> </s> </s> </s> </s> </s>

עם זאת, במצב שינה עמוק, הצריכה הנוכחית של ESP32 היא כמעט 150 אמ"א. אך הצריכה הנוכחית הרשומה עבור לוח ESP32 Devkit זה היא כמעט 4.10 mA. הסיבה לכך היא ה- CP2102 והרגולטור הליניארי. שני אלה מחוברים לקו החשמל 5V. יש גם נורית חשמל מחוברת בקו החשמל שצורכת כמעט 2mA זרם.

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