Low-power "mode":"minimum" example?

Hi All,

Blues newbie here.

I’ve got my cellular notecard working nicely sending environmental data to ubidots while reading the sensors with an esp32 feather.

Now I want to make it very low power for battery operation for sending soil moisture data every 1 hour, otherwise sleep or idle to keep power use low on my lipo.

Can someone direct me to a good example that shows how to use {“req”:“hub.set”,“mode”:“minimum”}
to put the notecard in a very low power state but then force a sync every 1 hour.

I saw the sleepysensor example, which was informative, but I really want control actions with my esp32 and not rely on the enable pin maneuver used in the sleepysensor example.
I also read this helpful article,
but would love to see the firmware that shows how someone puts this all together for low power monitoring.

Sorry for the noob question, I have perused the forum but could not find a good example for a beginner like me. I likely just didn’t search for the right key words.





Did try other ESP32 code to make the ESP32 in deep sleep mode and use only limited power?

Rob Oudendijk

BTW… Like the work you do and share with Measurement Lab.


Here are some snippets of code we use with an ESP32-S3 in Arduino that demon start how we a) have the device sleep in lower power mode, b) wake up every hour, take readings and transmit data. We also support DFU to update device firmware.

In the setup function, we call this code to configure the Notecard in minimum mode:

   bool enableSync() {
        J * req = notecard.newRequest("hub.set");
        JAddStringToObject(req, "product", productUID);
        JAddStringToObject(req, "mode", "minimum");	
        J * resp = notecard.requestAndResponse(req);
        bool success = !notecard.responseError(resp);


        // Disable Notecard Flashing MCU, but allow		DFU
        // preparatory downloading from Notehub to Notecard	DFU
        if (J *req = notecard.newRequest("card.dfu")) {	//DFU
            JAddStringToObject(req, "name", "esp32");	//DFU
            JAddBoolToObject(req, "off", true);		//DFU
            notecard.sendRequest(req);			//DFU
        return success;					//DFU

In the loop function, we take our readings and then start Notecard sync with this code:

    void startSync() {
        J * req = notecard.newRequest("hub.sync");
        JAddBoolToObject(req, "allow", true);

We then monitor the syncing process until complete, though the ESP32 is sometimes put in low power state and the Notecard finishes the sync.

We then query DFU status, if we detect that firmware has completely downloaded into Notecard, we call our performDFU routine, which switches the Notecard mode to continuous, installs the firmware and reboots the system.

    dfu_status_t dfu_ready = queryDFUStatus();   //DFU
    if ((dfu_ready == dfu_status_t:: DFUdownloading) || (dfu_ready ==  dfu_status_t:: DFUready)) {

The gotoSleep function, calculates the remaining time to the top of the hour, then calls:

    void deepSleep(int seconds) {

        J * req = NoteNewRequest("card.attn");
        JAddStringToObject(req, "mode", "arm,sleep,auxgpio");
        JAddNumberToObject(req, "seconds", seconds);

This puts Notecard to sleep for the specificied number of seconds. (Though if Notecard is still syncing, it will finish syncing).

Then we turn off on power in on our ESP32, and put ESP32 in deep sleep mode with:

esp_sleep_enable_ext0_wakeup(GPIO_NUM_15, 1);

At the top of the hour, the Notecard wakes up the ESP32 and the cycle repeats.

I hope this helps.



Thanks Karl, this is super helpful and just what I needed. Much appreciated! I will duplicate this strategy and report back if I have any issues.