Electronic – button which wakes up the esp8266 from deep sleep, but can be used as common button

esp8266

The goal is to have a button which wakes up the esp8266 from deep sleep, but can be used as common button while the code is running. This is a follow up of an unsolved Arduino SE question.

esp8266 can be wake up from deep sleep by connecting reset pin to ground. For timed deep sleep esp8266 uses io 16 to put reset LOW for wake up, so io 16 must be connected to reset pin for the timed deep sleep to work.

io 16 is a logical choice for our button. In this setup the button is connected to io 16 and reset wakes a sleeping esp8266, but resets a runnig esp8266. so we need to disconnect reset pin from io 16 (and button) while the code is running or ensure that reset pin is hold HIGH even if button connects pin 16 to ground.

schematic

^{simulate this circuit – Schematic created using CircuitLab}

(io 16 has no internal pullup, so externall pullup is needed)

What circuit is suitable for this?

Best Answer

First thing that comes to mind whenever I see a question similar to this is a diode. In this case, a diode you can "enable." Or... a BJT.

schematic

^{simulate this circuit – Schematic created using CircuitLab}

You'd want \$R_2\$ to be 10X the value for \$R_3\$. So, I'd probably recommend \$R_1=R_3=1\:\text{k}\Omega\$ and \$R_2=10\:\text{k}\Omega\$, as an initial guess of values to consider (or try.)

Set IO X to active-LO when you want to disable the RST being controlled by the switch.

Processors come out of reset with their IO pins as high impedance inputs. So, in the case where you haven't yet had time to configure IO X, because you just came out of RESET, the switch will still reset the processor.

Once you have time to set up IO X's activity, you can make sure that it is set to either of these:

RST disabled: Configure IO X as an output programmed for active-LO.
RST enabled: Configure IO X as an input or else very weak active-HI output (if that's possible on your processor.)

This allows you to control the activity of the switch and disable it's RST functionality when you are up and running and want it disabled. Regardless, the IO 16 behavior remains unaffected.

Here's a simulation of the circuit:

I won't vouch for the great colors here. But it gets the point across, I think.

The bottom trace (dark blue) is the activity of the switch itself. It is HI when the switch is actively being pressed. It is LO when the switch is released. (This is a control line I'm using for the Spice simulation only. So keep that in mind when interpreting it.)

The next trace up (magenta?) is the behavior of the IO 16 line. As you can see, it responds directly and always to the bottom trace's condition. It's never blocked or inhibited. It simply follows the behavior of the switch itself.

The next trace up (red) represents your control line, IO X. It is HI for case #1 above and LO for case #2 above. The LO condition represents the case where RST is enabled. The HI condition represents the case where RST is disabled. (If you look at the schematic, I've added a \$100\:\Omega\$ resistor in order to represent the typical output impedance of an IO pin, when LO.)

The top trace (green) represents the activity of the RST line in response to the traces below it. As you can see, it is only actively enabled to respond to the state of the switch when a specific set of conditions occur, as I believe you want here.

Related Solutions

Electronic – I need a switch that not only detects open/close, but also sends a pulse to wake up an ESP8266 whenever the (debounced) state changes

Added:

An XOR (Exclusive OR) gate (or XNOR) can be used to produce an output pulse on the rising or falling edges of an input signal. An XOR 'truth table' is:

IN Out

00 0
01 1
10 1
11 0

ie - the output is high when one only input is high. Both inputs low or both inputs high produce a low output.

In the diagram below the RC combination acts as a delay that causes any input level change to be delayed in arrival time at the RC connected input relative to the directly connected input. When a continuous high or low is input, both XOR inputs are the same polarity and output is low.
When the input level transitions there is a period of about t = R1 x C1 when the two inputs are not the same and an output pulse is produced.
Ideally Schmitt triggered inputs would be used, but std inputs "work OK" - subject to there being no input transients.

The RC only consume energy when the capacitor charges or discharges and this can be very small so the circuit achieves extremely low power consumption. CMOS gates when not switching draw sub microamp currents.

You can get single XOR gates in a package so small it's almost a breathing hazard. One of many is 74AHCT1G86SE-7

schematic

^{simulate this circuit – Schematic created using CircuitLab}

______________________________

Something as simple as this may work for you depending on overall application (as sometimes unspecific "extras" complicate the requirement).

This shows the general principle and you may have to 'play' somewhat.

/RST is assumed to have an internal pullup to Vdd. If not, one can be added.

Initially, SW1 open = uC sleeping.
SW1 closed = /RST low and Cd is charged low. SW1 open releases /RST and processor come out of sleep.
Cd level can be read via GPIO.
Cd level returns to Vdd = high after a period > t= RdCd.

If the switch is the only thing that brings the processor out of sleep then the GPIO read and no circuitry is needed except apart from the switch and a pullup for /RST (internal or external).

schematic

^{simulate this circuit}

Electrical – Extend ESP8266 12 F Deep Sleep Time

All they are suggesting is that you keep a counter in non-volatile memory so that you can keep track of how many times the ESP has woken up.

Sometimes you want to know if it's the very first time the application has run, so that you can do things you'd only want to do on the first boot. You can use a Boolean flag for this purpose. If you find out that you don't need that you can remove it from my example. Please note that I did not compile nor test this code, it could have errors and is meant purely as an example to get you started on a solution. Hope it helps :)

// NVM Data
#define RTCMemOffset 10 // arbitrary location
#define MAGIC_NUMBER 55 // used to know if the memory is good and been written to 

struct
{
    int wakeCount;
    bool bFirstTime;
    int magicNumber;
} nvmData;

nvmData sleepMemory;

bool bDoneSleeping;

void setup()
{
    /* Woke up and entered setup */
    bDoneSleeping = false;

    if(rtcUserMemoryRead((uint32_t)RTCMemOffset, (uint32_t*) &sleepMemory, sizeof(sleepMemory)))
    {
        if(sleepMemory.magicNumber != MAGIC_NUMBER) // memory got corrupt or this is the first time
        {
            sleepMemory.bFirstTime = true;
            sleepMemory.magicNumber = MAGIC_NUMBER;
            sleepMemory.wakeCount = 0;
        }
        else
        {
            sleepMemory.wakeCount += 1; // incrememnt the sleep counter
            sleepMemory.bFirstTime = false;
        }

        if(sleepMemory.wakeCount >= 4) // reset the counter and do whatever else you need to do since 4 hours have passed
        {
            sleepMemory.wakeCount = 0;
            bDoneSleeping = true;
        }   

        rtcUserMemoryWrite((uint32_t)RTCMemOffset, (uint32_t*) &sleepMemory, sizeof(sleepMemory)); // write the new values to memory
    }

    if(bDoneSleeping)
    {
         // Perform tasks
    }
    else
        // Go back to sleep
}

Best Answer

Related Solutions

Electronic – I need a switch that not only detects open/close, but also sends a pulse to wake up an ESP8266 whenever the (debounced) state changes

Electrical – Extend ESP8266 12 F Deep Sleep Time

Related Topic