ESP32 Deep Sleep dengan Arduino IDE dan Sumber Bangun

Artikel ini adalah panduan lengkap untuk mode Deep Sleep ESP32 dengan Arduino IDE. Kami akan menunjukkan cara membuat ESP32 tertidur lelap dan melihat berbagai mode untuk membangunkannya: penghitung waktu bangun, bangun sentuh, dan bangun eksternal. Panduan ini memberikan contoh praktis dengan kode, penjelasan kode, dan skema.

Artikel ini dibagi menjadi 4 bagian berbeda :

    • Memperkenalkan Mode Tidur Dalam

    • Timer Bangun

    • Sentuh Bangun

    • Bangun Eksternal

Memperkenalkan Mode Tidur Dalam

ESP32 dapat beralih di antara mode daya yang berbeda:

    • Mode aktif

    • Modem Mode tidur

    • Mode Tidur Ringan

    • Mode Tidur nyenyak

    • Mode hibernasi

Anda dapat membandingkan lima mode berbeda pada tabel berikut dari lembar data ESP32 Espressif.

Lembar data Espressif ESP32 juga menyediakan tabel yang membandingkan konsumsi daya dari berbagai mode daya.

Dan tabel berikut ini untuk membandingkan konsumsi daya dalam mode aktif :

Mengapa Mode Tidur Dalam?

Menjalankan ESP32 dalam mode aktif dengan baterai tidaklah ideal, karena daya dari baterai akan terkuras dengan sangat cepat.

Jika Anda menempatkan ESP32 Anda dalam mode tidur nyenyak, itu akan mengurangi konsumsi daya dan baterai Anda akan bertahan lebih lama.

Memiliki ESP32 Anda dalam mode tidur nyenyak berarti menghentikan aktivitas yang menghabiskan lebih banyak daya saat beroperasi, tetapi menyisakan aktivitas yang cukup untuk membangunkan prosesor saat sesuatu yang menarik terjadi.

Dalam mode deep sleep, tidak ada aktivitas CPU atau Wi-Fi yang terjadi, tetapi co-prosesor Ultra Low Power (ULP) masih dapat dihidupkan.

Saat ESP32 berada dalam mode deep sleep, memori RTC juga tetap menyala, sehingga kami dapat menulis program untuk co-prosesor ULP dan menyimpannya dalam memori RTC untuk mengakses perangkat periferal, timer internal, dan sensor internal.

Mode operasi ini berguna jika Anda perlu membangunkan CPU utama oleh peristiwa eksternal, pengatur waktu, atau keduanya, sambil mempertahankan konsumsi daya yang minimal.

Pin RTC_GPIO

Selama tidur nyenyak, beberapa pin ESP32 dapat digunakan oleh co-prosesor ULP, yaitu pin RTC_GPIO, dan Pin Sentuh. Lembar data ESP32 menyediakan tabel yang mengidentifikasi pin RTC_GPIO. Anda dapat menemukan tabel itu di sini di halaman 7.

Anda dapat menggunakan tabel tersebut sebagai referensi, atau lihat pinout berikut untuk menemukan pin RTC_GPIO yang berbeda. Pin RTC_GPIO disorot dengan kotak persegi panjang oranye.

Sumber Bangun

Setelah memasukkan ESP32 ke mode deep sleep, ada beberapa cara untuk membangunkannya:

    1. Anda dapat menggunakan pengatur waktu, membangunkan ESP32 Anda menggunakan periode waktu yang telah ditentukan;

    2. Anda dapat menggunakan pin sentuh;

    3. Anda dapat menggunakan dua kemungkinan pengaktifan eksternal: Anda dapat menggunakan salah satu pengaktifan eksternal, atau beberapa pengaktifan eksternal yang berbeda;

    4. Anda dapat menggunakan co-prosesor ULP untuk bangun – ini tidak akan tercakup dalam panduan ini.

Menulis Sketsa Tidur nyenyak

Untuk menulis sketsa untuk menempatkan ESP32 Anda ke mode tidur nyenyak, dan kemudian membangunkannya, Anda perlu mengingat bahwa :

    1. Pertama, Anda perlu mengonfigurasi sumber bangun. Ini berarti mengkonfigurasi apa yang akan membangunkan ESP32. Anda dapat menggunakan satu atau menggabungkan lebih dari satu sumber bangun.

    2. Anda dapat memutuskan periferal apa yang akan dimatikan atau dipertahankan selama tidur nyenyak. Namun, secara default, ESP32 secara otomatis mematikan periferal yang tidak diperlukan dengan sumber bangun yang Anda tentukan.

    3. Terakhir, Anda menggunakan fungsi esp_deep_sleep_start() untuk menempatkan ESP32 Anda ke mode deep sleep.

Timer Bangun

ESP32 dapat masuk ke mode tidur nyenyak, dan kemudian bangun pada periode waktu yang telah ditentukan. Fitur ini secara khusus berguna jika Anda menjalankan proyek yang memerlukan cap waktu atau tugas harian, sambil mempertahankan konsumsi daya yang rendah.

Pengontrol ESP32 RTC memiliki pengatur waktu bawaan yang dapat Anda gunakan untuk membangunkan ESP32 setelah waktu yang ditentukan sebelumnya.

Aktifkan Pengatur Waktu Bangun

Mengaktifkan ESP32 untuk bangun setelah jumlah waktu yang telah ditentukan sangat mudah. Di Arduino IDE, Anda hanya perlu menentukan waktu tidur dalam mikrodetik dalam fungsi berikut :

Kode

Mari kita lihat cara kerjanya menggunakan contoh dari perpustakaan. Buka Arduino IDE Anda, dan buka File > Example > ESP32 > Deep Sleep, dan buka sketsa TimerWakeUp.

 



Mari kita lihat kode ini. Komentar pertama menjelaskan apa yang dimatikan selama tidur nyenyak dengan timer bangun.

Saat Anda menggunakan timer bangun, bagian yang akan dihidupkan adalah pengontrol RTC, periferal RTC, dan memori RTC.

Tentukan Waktu Tidur

Dua baris kode pertama ini menentukan periode waktu ESP32 akan tidur.

Contoh ini menggunakan faktor konversi dari mikrodetik ke detik, sehingga Anda dapat menyetel waktu tidur dalam variabel TIME_TO_SLEEP dalam hitungan detik. Dalam hal ini, contoh akan menempatkan ESP32 ke mode deep sleep selama 5 detik.

Simpan Data di Memori RTC

Dengan ESP32, Anda dapat menyimpan data pada memori RTC. ESP32 memiliki SRAM 8kB pada bagian RTC, yang disebut memori cepat RTC. Data yang disimpan di sini tidak terhapus selama tidur nyenyak. Namun, itu terhapus ketika Anda menekan tombol reset (tombol berlabel EN pada papan ESP32).

Untuk menyimpan data pada memori RTC, Anda hanya perlu menambahkan RTC_DATA_ATTR sebelum definisi variabel. Contoh menyimpan variabel bootCount pada memori RTC. Variabel ini akan menghitung berapa kali ESP32 terbangun dari tidur nyenyak.

Alasan Bangun

Kemudian, kode mendefinisikan fungsi print_wakeup_reason(), yang mencetak alasan mengapa ESP32 dibangunkan dari tidur.

The setup()

Di setup() adalah tempat Anda harus meletakkan kode Anda. Dalam tidur nyenyak, sketsa tidak pernah mencapai pernyataan loop(). Jadi, Anda perlu menulis semua sketsa di setup().

Contoh ini dimulai dengan menginisialisasi komunikasi serial pada baud rate 115200.

Kemudian, variabel bootCount bertambah satu di setiap reboot, dan angka itu dicetak di monitor serial.

Kemudian, kode memanggil fungsi print_wakeup_reason(), tetapi Anda dapat memanggil fungsi apa pun yang Anda inginkan untuk melakukan tugas yang diinginkan. Misalnya, Anda mungkin ingin membangunkan ESP32 sekali sehari untuk membaca nilai dari sensor.

Selanjutnya, kode mendefinisikan sumber bangun dengan menggunakan fungsi berikut :

Fungsi ini menerima sebagai argumen waktu untuk tidur dalam mikrodetik seperti yang telah kita lihat sebelumnya.

Dalam kasus kami, kami memiliki yang berikut :

Kemudian, setelah semua tugas selesai, esp akan tidur dengan memanggil fungsi berikut :

The loop()

Bagian loop() kosong, karena ESP32 akan tidur sebelum mencapai bagian kode ini. Jadi, Anda perlu menulis semua sketsa Anda di setup().

Unggah sketsa contoh ke ESP32 Anda. Pastikan Anda memilih papan dan port COM yang tepat.

Menguji Pengatur Waktu Bangun

Buka Serial Monitor pada baud rate 115200.

Setiap 5 detik, ESP bangun, mencetak pesan di monitor serial, dan kembali tidur nyenyak.

Setiap kali ESP bangun, variabel bootCount meningkat. Itu juga mencetak alasan bangun seperti yang ditunjukkan pada gambar di bawah ini.

Namun, perhatikan bahwa jika Anda menekan tombol EN pada papan ESP32, itu akan mengatur ulang jumlah boot ke 1 lagi.

Anda dapat mengubah contoh yang diberikan, dan alih-alih mencetak pesan, Anda dapat membuat ESP Anda melakukan tugas lain. Pengatur waktu bangun berguna untuk melakukan tugas berkala dengan ESP32, seperti tugas sehari-hari, tanpa menguras banyak daya.

Sentuh Bangun

Anda dapat membangunkan ESP32 dari tidur nyenyak menggunakan pin sentuh. Bagian ini menunjukkan bagaimana melakukannya menggunakan Arduino IDE.

Aktifkan Touch Wake Up

Mengaktifkan ESP32 untuk bangun menggunakan touchpin itu sederhana. Di Arduino IDE, Anda perlu menggunakan fungsi berikut:

Kode

Mari kita lihat cara kerjanya menggunakan contoh dari perpustakaan. Buka Arduino IDE Anda, dan buka File > Example > ESP32 > Deep Sleep, dan buka sketsa TouchWakeUp.





Mengatur Ambang Batas

Hal pertama yang perlu Anda lakukan adalah menetapkan nilai ambang batas untuk pin sentuh. Dalam hal ini kami menyetel Ambang ke 40. Anda mungkin perlu mengubah nilai ambang tergantung pada proyek Anda.

Saat Anda menyentuh GPIO yang sensitif terhadap sentuhan, nilai yang dibaca oleh sensor akan berkurang. Jadi, Anda dapat mengatur nilai ambang yang membuat sesuatu terjadi ketika sentuhan terdeteksi.

Nilai ambang batas yang ditetapkan di sini berarti bahwa ketika nilai yang dibaca oleh GPIO peka sentuhan di bawah 40, ESP32 akan aktif. Anda dapat menyesuaikan nilai tersebut sesuai dengan sensitivitas yang diinginkan.

Lampirkan Interupsi

Anda perlu memasang interupsi ke pin sensitif sentuhan. Saat sentuhan terdeteksi pada GPIO tertentu, fungsi panggilan balik dijalankan. Sebagai contoh, perhatikan baris berikut:

Ketika nilai yang terbaca pada T3 (GPIO 15) lebih rendah dari nilai yang ditetapkan pada variabel Threshold, ESP32 bangun dan fungsi callback dijalankan.

Fungsi callback() hanya akan dijalankan jika ESP32 terjaga.

    • Jika ESP32 tertidur dan Anda menyentuh T3, ESP akan bangun – fungsi callback() tidak akan dijalankan jika Anda hanya menekan dan melepaskan pin sentuh;

    • Jika ESP32 aktif dan Anda menyentuh T3, fungsi panggilan balik akan dijalankan. Jadi, jika Anda ingin menjalankan fungsi callback() saat mengaktifkan ESP32, Anda perlu menahan sentuhan pada pin tersebut untuk beberapa saat, hingga fungsi tersebut dijalankan.

Jika Anda ingin membangunkan ESP32 menggunakan pin sentuh yang berbeda, Anda hanya perlu memasang interupsi ke pin tersebut.

Selanjutnya, Anda perlu menggunakan fungsi esp_sleep_enable_touchpad_wakeup() untuk menyetel pin sentuh sebagai sumber pengaktifan.

Skema

Untuk menguji contoh ini, sambungkan kabel ke GPIO 15, seperti yang ditunjukkan pada skema di bawah ini.

(Skema ini menggunakan versi modul ESP32 DEVKIT V1 dengan 30 GPIO – jika Anda menggunakan model lain, periksa pinout untuk papan yang Anda gunakan.)

Menguji Contoh

Unggah kode ke ESP32 Anda, dan buka Serial Monitor pada baud rate 115200.

ESP32 masuk ke mode tidur nyenyak.

Anda dapat membangunkannya dengan menyentuh kabel yang terhubung ke Touch Pin 3

Saat Anda menyentuh pin, ESP32 ditampilkan di Serial Monitor: nomor boot, penyebab bangun, dan di mana GPIO touch terdeteksi.

Bangun Eksternal

Selain timer dan pin sentuh, kita juga dapat membangunkan ESP32 dari tidur nyenyak dengan mengubah nilai sinyal pada pin, seperti menekan tombol. Ini disebut bangun eksternal. Anda memiliki dua kemungkinan bangun eksternal: ext0, dan ext1.

Bangun Eksternal (ext0)

Sumber bangun ini memungkinkan Anda menggunakan pin untuk membangunkan ESP32.

Opsi sumber bangun ext0 menggunakan RTC GPIO untuk bangun. Jadi, periferal RTC akan tetap menyala selama tidur nyenyak jika sumber bangun ini diminta.

Untuk menggunakan sumber bangun ini, Anda menggunakan fungsi berikut :

Fungsi ini menerima sebagai argumen pertama pin yang ingin Anda gunakan, dalam format ini GPIO_NUM_X, di mana X mewakili nomor GPIO dari pin tersebut.

Argumen kedua, level, dapat berupa 1 atau 0. Ini mewakili status GPIO yang akan memicu bangun.

Catatan : dengan sumber bangun ini, Anda hanya dapat menggunakan pin yang merupakan GPIO RTC.

Bangun Eksternal (ext1)

Sumber bangun ini memungkinkan Anda menggunakan beberapa RTC GPIO. Anda dapat menggunakan dua fungsi logika yang berbeda:

    • Bangunkan ESP32 jika salah satu pin yang Anda pilih tinggi;

    • Bangunkan ESP32 jika semua pin yang Anda pilih rendah.

Sumber bangun ini diimplementasikan oleh pengontrol RTC. Jadi, periferal RTC dan memori RTC dapat dimatikan dalam mode ini.

Fungsi ini menerima dua argumen :

    • Sebuah bitmask dari nomor GPIO yang akan menyebabkan bangun;

    • Mode: logika untuk membangunkan ESP32. Ini bisa berupa:

        • ESP_EXT1_WAKEUP_ALL_LOW: bangun saat semua GPIO hampir habis;

        • ESP_EXT1_WAKEUP_ANY_HIGH: bangun jika salah satu GPIO menjadi tinggi.

Catatan : dengan sumber bangun ini, Anda hanya dapat menggunakan pin yang merupakan GPIO RTC.

Kode

Mari kita jelajahi contoh yang disertakan dengan perpustakaan ESP32. Buka File > Example > ESP32 > Deep Sleep > ExternalWakeUp :






Contoh ini membangunkan ESP32 saat Anda memicu GPIO 33 ke tinggi. Contoh kode menunjukkan cara menggunakan kedua metode: ext0 dan ext1. Jika Anda mengunggah kode apa adanya, Anda akan menggunakan ext0. Fungsi untuk menggunakan ext1 dikomentari. Kami akan menunjukkan cara kerja kedua metode dan cara menggunakannya.

Kode ini sangat mirip dengan yang sebelumnya di artikel ini. Di setup(), Anda mulai dengan menginisialisasi komunikasi serial:

Kemudian, Anda menambahkan satu ke variabel bootCount, dan mencetak variabel itu di Serial Monitor.

Selanjutnya, Anda mencetak alasan bangun menggunakan fungsi print_wakeup_reason() yang ditentukan sebelumnya.

Setelah ini, Anda perlu mengaktifkan sumber bangun. Kami akan menguji masing-masing sumber bangun, ext0 dan ext1, secara terpisah.

ext0

Dalam contoh ini, ESP32 bangun ketika GPIO 33 dipicu ke tinggi:

Alih-alih GPIO 33, Anda dapat menggunakan pin RTC GPIO lainnya.

Skema

Untuk menguji contoh ini, sambungkan tombol tekan ke ESP32 Anda dengan mengikuti diagram skema berikut. Tombol terhubung ke GPIO 33 menggunakan resistor 10K Ohm pull down.

(Skema ini menggunakan versi modul ESP32 DEVKIT V1 dengan 30 GPIO – jika Anda menggunakan model lain, periksa pinout untuk papan yang Anda gunakan.)

Catatan : hanya RTC GPIO yang dapat digunakan sebagai sumber pengaktifan. Alih-alih GPIO 33, Anda juga dapat menggunakan pin RTC GPIO apa pun untuk menghubungkan tombol Anda.

Menguji Contoh

Mari kita uji contoh ini. Unggah kode contoh ke ESP32 Anda. Pastikan Anda memilih papan dan port COM yang tepat. Buka Serial Monitor pada baud rate 115200.

Tekan tombol untuk membangunkan ESP32.

Coba ini beberapa kali, dan lihat jumlah boot meningkat di setiap penekanan tombol.

Menggunakan metode ini berguna untuk membangunkan ESP32 Anda menggunakan tombol tekan, misalnya untuk membuat tugas tertentu. Namun, dengan metode ini Anda hanya dapat menggunakan satu GPIO sebagai sumber bangun.

Bagaimana jika Anda ingin memiliki tombol yang berbeda, semuanya membangunkan ESP, tetapi melakukan tugas yang berbeda? Untuk itu Anda perlu menggunakan metode ext1.

ext1

Ext1 memungkinkan Anda untuk membangunkan ESP menggunakan tombol yang berbeda dan melakukan tugas yang berbeda tergantung pada tombol yang Anda tekan.

Alih-alih menggunakan fungsi esp_sleep_enable_ext0_wakeup() , Anda menggunakan fungsi esp_sleep_enable_ext1_wakeup() . Dalam kode, fungsi itu dikomentari :

Batalkan komentar pada fungsi itu sehingga Anda memiliki :

Argumen pertama dari fungsi tersebut adalah bitmask dari GPIO yang akan Anda gunakan sebagai sumber pengaktifan, dan argumen kedua mendefinisikan logika untuk membangunkan ESP32.

Dalam contoh ini kami menggunakan variabel BUTTON_PIN_BITMASK, yang didefinisikan di awal kode:

Ini hanya mendefinisikan satu pin sebagai sumber pengaktifan, GPIO 33. Anda perlu memodifikasi bitmask untuk mengonfigurasi lebih banyak GPIO sebagai sumber pengaktifan.

GPIO Bitmask

Untuk mendapatkan bitmask GPIO, ikuti langkah-langkah berikut:

1. Hitung 2^(GPIO_NUMBER). Simpan hasilnya dalam desimal;

2. Buka rapidtables.com/convert/number/decimal-to-hex.html dan ubah angka desimal menjadi hex;

3. Ganti nomor hex yang Anda peroleh di variabel BUTTON_PIN_BITMASK.

Masker untuk satu GPIO

Agar Anda memahami cara mendapatkan bitmask GPIO, mari kita lihat sebuah contoh. Dalam kode dari perpustakaan, tombol terhubung ke GPIO 33. Untuk mendapatkan topeng untuk GPIO 33 :

1. Hitung 2^33. Anda harus mendapatkan 8589934592;

2. Ubah bilangan tersebut (8589934592) menjadi heksadesimal. Anda dapat membuka konverter ini untuk melakukannya :

3. Salin nomor Hex ke variabel BUTTON_PIN_BITMASK, dan Anda akan mendapatkan : 

Masker untuk beberapa GPIO

Jika Anda ingin menggunakan GPIO 2 dan GPIO 15 sebagai sumber pengaktifan, Anda harus melakukan hal berikut:

    • Hitung 2^2 + 2^15. Anda harus mendapatkan 32772

    • Ubah angka itu menjadi heksa. Anda harus mendapatkan: 8004

    • Ganti nomor tersebut di BUTTON_PIN_BITMASK sebagai berikut:

Mengidentifikasi GPIO yang digunakan sebagai sumber bangun

Saat Anda menggunakan beberapa pin untuk membangunkan ESP32, penting untuk mengetahui pin mana yang menyebabkan bangun. Untuk itu, Anda dapat menggunakan fungsi berikut :

Fungsi ini mengembalikan sejumlah basis 2, dengan nomor GPIO sebagai eksponen: 2^(GPIO). Jadi, untuk mendapatkan GPIO dalam desimal, Anda perlu melakukan perhitungan berikut :

Fungsi ini mengembalikan sejumlah basis 2, dengan nomor GPIO sebagai eksponen: 2^(GPIO). Jadi, untuk mendapatkan GPIO dalam desimal, Anda perlu melakukan perhitungan berikut :

Bangun Eksternal – Beberapa GPIO

Sekarang, Anda harus dapat membangunkan ESP32 menggunakan tombol yang berbeda, dan mengidentifikasi tombol mana yang menyebabkan bangun. Dalam contoh ini kita akan menggunakan GPIO 2 dan GPIO 15 sebagai sumber bangun.

Skema

Hubungkan dua tombol ke ESP32 Anda. Dalam contoh ini kami menggunakan GPIO 2 dan GPIO 15, tetapi Anda dapat menghubungkan tombol Anda ke GPIO RTC apa pun.

Kode

Anda perlu membuat beberapa modifikasi pada kode contoh yang telah kami gunakan sebelumnya :

    • Buat bitmask untuk menggunakan GPIO 15 dan GPIO 2. Kami telah menunjukkan cara melakukannya sebelumnya;

    • Aktifkan ext1 sebagai sumber bangun;

    • Gunakan fungsi esp_sleep_get_ext1_wakeup_status() untuk mendapatkan GPIO yang memicu bangun.

Sketsa berikutnya telah menerapkan semua perubahan itu.

 






Anda menentukan topeng GPIO di awal kode :

Anda membuat fungsi untuk mencetak GPIO yang menyebabkan bangun :

Dan akhirnya, Anda mengaktifkan ext1 sebagai sumber bangun :

Menguji Sketsa

Memiliki dua tombol yang terhubung ke GPIO 2 dan GPIO 15, Anda dapat mengunggah kode yang diberikan ke ESP32 Anda. Pastikan Anda memilih papan dan port COM yang tepat.

ESP32 dalam mode tidur nyenyak sekarang. Anda dapat membangunkannya dengan menekan tombol.

Buka Serial Monitor pada baud rate 115200. Tekan tombol untuk mengaktifkan ESP32.

Anda harus mendapatkan sesuatu yang serupa di monitor serial.

Membungkus

Dalam artikel ini kami telah menunjukkan kepada Anda cara menggunakan tidur nyenyak dengan ESP32 dan berbagai cara untuk membangunkannya. Anda dapat membangunkan ESP32 menggunakan timer, pin sentuh, atau perubahan status GPIO.

Mari kita rangkum apa yang telah kita lihat tentang setiap sumber bangun :

Timer Bangun

    • Untuk mengaktifkan timer bangun, Anda menggunakan fungsi esp_sleep_enable_timer_wakeup(time_in_us);

    • Gunakan fungsi esp_deep_sleep_start() untuk memulai tidur nyenyak.

Sentuh Bangun

    • Untuk menggunakan pin sentuh sebagai sumber pengaktifan, pertama, Anda harus melampirkan interupsi ke pin sentuh menggunakan: touchAttachInterrupt(Touchpin, callback, Threshold)

    • Kemudian, Anda mengaktifkan pin sentuh sebagai sumber pengaktifan menggunakan: esp_sleep_enable_touchpad_wakeup()

    • Terakhir, Anda menggunakan fungsi esp_deep_sleep_start() untuk menempatkan ESP32 dalam mode deep sleep.

Bangun Eksternal

    • Anda hanya dapat menggunakan RTC GPIO sebagai pengaktifan eksternal;

    • Anda dapat menggunakan dua metode berbeda: ext0 dan ext1;

    • ext0 memungkinkan Anda untuk membangunkan ESP32 menggunakan satu pin GPIO tunggal;

    • ext1 memungkinkan Anda untuk membangunkan ESP32 menggunakan beberapa pin GPIO.

Kami harap panduan ini bermanfaat bagi Anda. Jika Anda ingin mempelajari lebih lanjut tentang ESP32, pastikan Anda memeriksa semua proyek ESP32 dan kursus ESP32 kami.

Posting Komentar

0 Komentar