ბატარეის დაზოგვა ღრმა ძილით: 20 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

გაინტერესებთ ბატარეის გამოყენება ESP32– ით? თუ ასეა, მე დღეს განვიხილავ რამდენიმე მნიშვნელოვან ტექნიკურ ინფორმაციას ამ თემაზე. ჩვენ ვიცით, რომ ეს მიკროკონტროლერი ხარჯავს უამრავ ენერგიას ინფორმაციის გადაცემისას. ის მოიხმარს 190 მილიამპერამდე. ამ ვიდეოში მე ვაჩვენებ, როგორ შევინარჩუნოთ ენერგია ESP32– დან ეგრეთწოდებული „ღრმა ძილი“ფუნქციით. ჩვენ დავაყენებთ ჩიპს, რომ შევიდეს ამ რეჟიმში, ვისწავლოთ ამ რეჟიმიდან გამოსვლის გზები და შევქმნათ მაგალითი, რომელიც აჩვენებს ESP32– ის გაღვიძების სამ განსხვავებულ გზას.

მნიშვნელოვანია გვახსოვდეს, რომ რადიო ხარჯავს ბევრ ენერგიას, ვიდრე პროცესორს. ენერგიის დაზოგვა ძალიან მნიშვნელოვანია. ეს იმიტომ ხდება, რომ საბოლოო წერტილები (სქემები, რომლებიც აგზავნიან ინფორმაციას) ხშირად ბატარეაზეა და უნდა გაგრძელდეს ხუთ წლამდე. არსებობს მწარმოებლები, რომლებიც გპირდებიან ათ წლამდე ხანგრძლივობას და ეს მოქმედებს მაღალი ხარისხის ბატარეებზე, რომლებიც ბოლომდე არ იყენებენ იმდენს. ყველა სხვა შემთხვევაში, მე გირჩევთ გამოიყენოთ ღრმა ძილი, რომ დაზოგოთ ენერგია თქვენი წრიდან.

ნაბიჯი 1: შესავალი

ESP32– ს აქვს ენერგიის დაზოგვის რეჟიმი, სახელწოდებით „ღრმა ძილი“. ამ რეჟიმში, პროცესორები, ოპერატიული მეხსიერება და ყველა ციფრული პერიფერიული მოწყობილობა გამორთულია. ჩიპის ერთადერთი ნაწილი, რომლის დაკავშირებაც შესაძლებელია, არის 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 level)

gpio_num> GPIO ნომერი გამოიყენება როგორც აქტივაციის წყარო. შესაძლებელია მხოლოდ RTC- ფუნქციური GPIO- ების გამოყენება: 0, 2, 4, 12-15, 25-27, 32-39.

დონე> შეყვანის დონე, რომელიც გამოიწვევს განგაში (0 = დაბალი, 1 = მაღალი)

ნაბიჯი 5: გარე გაღვიძება (ext1)

RTC კონტროლერი შეიცავს ლოგიკას, რომ გამოიწვიოს მაღვიძარა რამოდენიმე RTC GPIO- ს გამოყენებით.

esp_deep_sleep_enable_ext1_wakeup (uint64_t ნიღაბი, esp_ext1_wakeup_mode_t რეჟიმი)

ნიღაბი> GPIO ნომრების ბიტ -ნიღაბი, რაც გამოიწვევს გააქტიურებას. ამ ბიტმაპაში შეიძლება გამოყენებულ იქნას მხოლოდ RTC- ჩართული GPIO: 0, 2, 4, 12-15, 25-27, 32-39.

რეჟიმი> აირჩიეთ ლოგიკური ფუნქცია, რომელიც გამოიყენება გააქტიურების მდგომარეობის დასადგენად:

• ESP_EXT1_WAKEUP_ALL_LOW: იღვიძებს, როდესაც ყველა არჩეული GPIO არის LOW

• ESP_EXT1_WAKEUP_ANY_HIGH: იღვიძებს, როდესაც რომელიმე არჩეული GPIO არის მაღალი

ნაბიჯი 6: ULP კოპროცესორული გაღვიძება

ULP თანაპროცესორს შეუძლია იმუშაოს სანამ ჩიპი ღრმა ძილშია და მისი გამოყენება შესაძლებელია სენსორების მოსაძიებლად, ADC- ს ან capacitive touch სენსორის მნიშვნელობების მონიტორინგისთვის და ჩიპის გააქტიურებისათვის, როდესაც კონკრეტული მოვლენა გამოვლინდება.

ULP კოპროცესორი არის RTC პერიფერიული მოწყობილობების დომენის ნაწილი და მუშაობს ნელი მეხსიერების RTC- ში შენახულ პროგრამაზე. ამრიგად, RTC პერიფერიული მოწყობილობები და RTC ნელი მეხსიერება გააქტიურდება ღრმა ძილის დროს, თუ ეს გააქტიურების რეჟიმია მოთხოვნილი.

ნაბიჯი 7: სენსორული პანელი

RTC კონტროლერი შეიცავს ლოგიკას, რომ გამოიწვიოს სიგნალიზაცია capacitive touch სენსორების გამოყენებით. შეხების პინის განმარტება განსხვავებულია. ჩვენ უნდა გამოვიყენოთ შეხების შეწყვეტა თითოეული სასურველი ქინძისთავისთვის.

შეფერხებების დაყენების შემდეგ, ჩვენ ჩართეთ გაღვიძების რეჟიმი სენსორების გამოყენებისათვის.

// Touchpad- ის კონფიგურაცია გაღვიძების წყაროს სახით esp_sleep_enable_touchpad_wakeup ();

ნაბიჯი 8: ღრმა ძილის რეჟიმში შესვლა

გაღვიძების რეჟიმის დაყენების შემდეგ, საკმარისია ერთი ბრძანება ESP32 ღრმა ძილის რეჟიმში (2.5 μA ან ნაკლები დახარჯვა). აქ ხაზს ვუსვამ, რომ ეს ხარჯი არის 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 არომატირებული მეხსიერებისთვის RTCRTC_DATA_ATTR int bootCount = 0;

ნაბიჯი 10: დემონსტრაცია

ვიდეო აჩვენებს პროგრამის მუშაობას, სურათის შესაბამისად.

ნაბიჯი 11: WiFi NodeMCU-32S ESP-WROOM-32

ნაბიჯი 12: შეკრება

ნაბიჯი 13: პროგრამა

ჩვენ ახლა შევქმნით პროგრამას, სადაც ჩვენ დავაკონფიგურირებთ ESP32 ღრმა ძილის რეჟიმში შესასვლელად. ეს გაღვიძდება სამი განსხვავებული გზით: ერთი გარე გაღვიძებისთვის (ext0), ერთი ტაიმერისთვის და ერთი Touchpad– ისთვის. მათ არ შეუძლიათ ერთად მუშაობა, ამიტომ ჩვენ გამოვიყენებთ ცვლადს, რომელიც იქნება მრიცხველი რამდენჯერმე ESP32- მა მისცა ჩატვირთვა გამოღვიძების გზის კონფიგურაციისთვის.

ნაბიჯი 14: საჭიროა ბიბლიოთეკა

OLED ეკრანის გასაკონტროლებლად, ჩვენ გვჭირდება გარე ბიბლიოთეკა. ამისათვის ჩვენ გადმოვტვირთავთ U8g2 ბიბლიოთეკას.

Arduino IDE– ში გადადით ესკიზის მენიუში >> ბიბლიოთეკის ჩართვა >> ბიბლიოთეკების მართვა….

ნაბიჯი 15: ბიბლიოთეკები და ცვლადები

ჩვენ შევიტანეთ ბიბლიოთეკა OLED ეკრანის გასაკონტროლებლად, ასევე ეკრანის კონტროლერის ინსტანციის კონსტრუქტორი. ასევე, ჩვენ გამოვყოფთ ცვლადს RTC მეხსიერებაში. ჩვენ ვადგენთ მგრძნობელობას შეხების მისაღებად, მიკროწამში კონვერტაციის ფაქტორს წამებში და დროს ESP32 ძილის რეჟიმში გადადის (წამში).

#include // biblioteca para control do do oled

// კონსტრუქტორი ინსტანციაზე კონტროლის ჩვენებისათვის // SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C ჩვენება (SCL, SDA, U8X8_PIN_NONE); // RTC_DATA_ATTR არომატი სხვადასხვა მეხსიერებაში 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) #განსაზღვრეთ TIME_TO_SLEEP

ნაბიჯი 16: დაყენება

Setup– ში ჩვენ ვამატებთ ჩატვირთვისას რამდენჯერმე. ჩვენ ვიძახებთ ჩატვირთვის მოტივის დაბეჭდვის ფუნქციას. თუ ჩატვირთვის ნომერი არის PAR, ჩვენ ვაყენებთ ESP32– ს გაღვიძებას ღილაკით (EXT0). თუ ეს არის 3 – ის ჯერადი, ჩვენ ვაყენებთ ESP32– ს გაღვიძებას განსაზღვრული დროის შემდეგ. წინააღმდეგ შემთხვევაში, ჩვენ დავაყენებთ capacitive touch pins, რომ გამოვიღოთ ESP32. დაბოლოს, ჩვენ დავაყენეთ Touchpad როგორც გაღვიძების წყარო და ვაიძულეთ ESP32 შევიდეს ძილის რეჟიმში.

void setup () {Serial.begin (115200); დაგვიანება (1000); // რიცხვითი რიცხვის გაზრდა ჩატვირთვისას ++ bootCount; configureDisplay (); // chama a função para imprimir o motivo do BOOT print_wakeup_reason (); // იხილეთ რიცხვის ჩატვირთვის PAR კონფიგურაციისთვის ან ESP32 სისტემის დაყენების მიზნით (EXT0) if (bootCount % 2 == 0) {esp_sleep_enable_ext0_wakeup (GPIO_NUM_39, 1); // 1 = მაღალი, 0 = დაბალი} // se for multiplo de 3 configuramos o ESP32 for despertar depois de um tempo definido else if (bootCount % 3 == 0) {esp_sleep_enable_timer_wakeup (TIME_TO_SLEEP * uS_TO_S_FACTOR); } // caso contrario configuramos os pinos de touch capacitivo des despertar o ESP32 else {// Setup interrupt on Touch Pad 5 (GPIO12) touchAttachInterrupt (T5, callback, Threshold); // Touchpad- ის კონფიგურაცია გაღვიძების წყაროს სახით esp_sleep_enable_touchpad_wakeup (); } Serial.println ("entrando em modo sleep"); esp_deep_sleep_start (); // força o ESP32 entrar em modo SLEEP}

ნაბიჯი 17: Loop, Callback & ConfigureDisplay

მარყუჟში, ჩვენ არაფერი გვაქვს გასაკეთებელი. შემდეგ ჩვენ ვაგრძელებთ ზარის დაბრუნების შეწყვეტას, თუკი რაიმე გვაქვს გასაკეთებელი შეფერხების დროს. რაც შეეხება 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 () {// ოფიციალური ჩვენება და კონფიგურაციის ალგუნი პარამეტრების ჩვენება. დაწყება (); 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, სიმებიანი (bootCount).c_str ()); display.drawString (0, 4, "MOTIVO:"); }

ნაბიჯი 18: ამობეჭდვის_გამოღვიძების_მიზეზი (იცოდე გამოღვიძების მიზეზი)

აქ ჩვენ გვაქვს ფუნქცია ამობეჭდოთ 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 switch (wakeup_reason) {case 1: reason = "EXT0 RTC_IO BTN"; შესვენება; შემთხვევა 2: მიზეზი = "EXT1 RTC_CNTL"; შესვენება; შემთხვევა 3: მიზეზი = "დრო"; შესვენება; შემთხვევა 4: მიზეზი = "TOUCHPAD"; შესვენება; შემთხვევა 5: მიზეზი = "ULP პროგრამა"; შესვენება; ნაგულისხმევი: reason = "NO DS CAUSE"; შესვენება; } Serial.println (მიზეზი); display.clearLine (6); // apaga a linha 6 do display.drawString (0, 6, reason.c_str ()); // imprime a causa do despertar არა ჩვენება // 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 არა ჩვენება}}

ნაბიჯი 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 (); // აღდგენა GPIO ან despertou o ESP32 სიმებიანი GPIO = ""; გადართვა (touchPin) {შემთხვევა 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 ("გაღვიძება არა touchpad- ით"); შესვენება; } Serial.println ("GPIO:"+GPIO); display.clearLine (7); // apaga a linha 7 do display.drawString (0, 7, "GPIO:"); display.drawString (6, 7, GPIO.c_str ()); // imprime o GPIO}

ნაბიჯი 20: ჩამოტვირთეთ ფაილები

PDF

ინო