Problema de interrupción faltante con Attiny85

Vas a dormir incondicionalmente en cada iteración de loop() . Eso no es lo que quieres. La forma en que se encuentra su código ahora, se perderá cada evento de activación que ocurre mientras se ejecuta su código de programa normal.

Su código pasa la mayor parte del tiempo retrasando dentro de flash() . Y el controlador se pone en suspensión después de que se haya completado flash() . Siempre. Esto significa que siempre que ocurra un evento de activación mientras el LED está parpadeando, no provocará una activación. Esto se debe a que la interrupción ocurrió y fue reparada antes que se fue a dormir.

Eche un vistazo al ejemplo en avr-libc docs aquí .

Tu código debería tener este aspecto:

void loop(){

  cli(); // Disable interrupts to avoid race condition.

  if ( !resetEsp ) {
    // Only go to sleep if we have nothing to do right now.
    // Safe(*) code from the example in avr-libc:
    sleep_enable();
    sei();
    sleep_cpu();
    sleep_disable();    
  } else {
    sei(); // Can go on processing IRQs.
  }

  if (resetEsp) {

    cli();

    resetEsp = false; // clear the flags
    resetEnabled = false;

    sei();

    digitalWrite(pinRST, LOW); // reset the ESP
    delayMicroseconds(240);
    digitalWrite(pinRST, HIGH); // let the ESP Boot    
    flash(10, 50); // flash the led fast to show we're waking the ESP

  } else if (resetEnabled) {
    flash(10, 500);  // mostly never get here
  } else {
    flash(2, 500);   // these are the flashes I see most of the time
  }

}

El punto aquí es que deshabilitamos todas las interrupciones mientras verificamos si queremos ir a dormir. De esta manera, nos aseguramos de que no se produzcan interrupciones después de que verificamos, pero antes en realidad dormimos. Sin embargo, es crucial que activemos las interrupciones nuevamente antes de irnos a dormir, o nunca volveremos a despertarnos.

Además, @jms tiene razón al afirmar que tienes otra posible codificación de carrera al restablecer tus banderas, así que incluye algunos cli / sei allí también.

set_sleep_mode(SLEEP_MODE_PWR_DOWN); puede ir a setup() . Y si no estás controlando naves espaciales, lo mismo vale para sleep_enable(); , mientras que omites sleep_disable(); por completo.

(*) El código etiquetado como "seguro" arriba no es absolutamente a prueba de balas porque, en teoría, durante la optimización, el compilador podría decidir reordenar algunas instrucciones para que sei() y sleep_cpu() Podría acabar no estando en secuencia directa. Para estar absolutamente seguro, verifique el código del ensamblador generado ( gcc -save-temps ), o simplemente escriba las instrucciones requeridas como ensamblador en línea usted mismo. (Puede ser tan simple como asm volatile (" sei \r\n sleep \r\n " :::); .)

Estoy bastante seguro de que este es un problema de concurrencia clásico que surge al borrar los dos indicadores después de restablecer el ESP.

ATtiny boots, initializes, resetEnabled set 
Main loop starts, ATtiny goes asleep.
IR pulse arrives
ATtiny wakes up, ISR executes, resetEsp set
Main loop code resets ESP                   ==>      ESP wakes up
Main loop code starts flashing LED                   ESP does stuff
ISR executes, doesn't do anything           <==      ESP enables IR reset
Main loop code finishes flashing LED                 ESP goes asleep
ResetEsp and resetEnabled cleared               
ATtiny goes asleep, resetEnabled is never set again  
IR pulse arrives, ISR executes, ESP reset skipped 

A veces, el ATtiny podría funcionar como se esperaba si el ESP toma el tiempo suficiente para hacer su trabajo antes de activar la interrupción.

La solución es simple, borre las marcas antes restableciendo el ESP.

void loop()
{
    system_sleep();
    if(resetEsp)
    {
        cli(); //prevent an interrupt from firing while 
               //..clearing the flags and messing them up
        resetEsp = false; // clear the flags
        resetEnabled = false;
        sei();
        digitalWrite(pinRST, LOW); // reset the ESP
        delayMicroseconds(240);
        digitalWrite(pinRST, HIGH); // let the ESP Boot    
        flash(10, 50); // flash the led fast to show we're waking the ESP
    }
    else
        flash(2, 500);   //reset by IR not enabled 
}

EDITAR:

Como descubrió @JimmyB, hay un segundo descuido tanto en el código de la pregunta original como en mi respuesta original. Si los reinicios de ESP IR están habilitados y llega un pulso de IR mientras el ATtiny está activo , el ATtiny se pondrá en suspensión sin reiniciar el AVR y tomará un segundo pulso de IR superfluo para activar un reinicio el ESP.

Para solucionar esto, el indicador resetEsp debe volver a comprobarse (mientras que las interrupciones están desactivadas) justo antes de quedarse dormido, y la última instrucción antes de que la instrucción de suspensión vuelva a habilitar las interrupciones. De esta manera, si llega un pulso de IR mientras se está comprobando nuevamente el indicador resetEsp, la transición del modo de suspensión se cancelará por la interrupción pendiente.

Este código también debería solucionar ese problema.

void loop()
{
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    cli();
    if(!resetEsp)
    {
        sleep_enable();         //Set the sleep enable bit, allowing the sleep instruction to work.
        sei();                  //Enable interrupts one cycle before falling asleep. If an 
        sleep_cpu();            //..interrupt is pending, the ISR will abort the sleeping process
        sleep_disable();        //Clear the sleep enable bit
    }
    else
        sei();

    if(resetEsp)
    {
        cli();                  //prevent an interrupt from messing with the flags while 
                                //..main loop code is in the process of clearing them
        resetEsp = false;       // clear the flags
        resetEnabled = false;
        sei();
        digitalWrite(pinRST, LOW); // reset the ESP
        delayMicroseconds(240);
        digitalWrite(pinRST, HIGH); // let the ESP Boot    
        flash(10, 50);          // signal that the ESP has been reset
    }
    else
    {
        if(resetEnabled)
            flash(10, 500);     //signal that the ESP has enabled IR resets
        else
            flash(2, 500);      //signal that the IR pulse was ignored
    }
}  

EDIT 2:

Aquí está el código completo de una implementación basada en una sola variable de estado. También modifiqué la forma en que se maneja la línea de reinicio de ESP: ahora, normalmente, se deja que la línea de reinicio flote sin ser impulsada, y se lleva a tierra brevemente cuando se ordena un reinicio.

#include <avr/sleep.h>
#include <cstdint.h>

//IO pin bit definitions
#define IR_IN               0
#define LED_OUT             1
#define RST_ENABLE_IN       2
#define RST_OUT             3

//State definitions
#define IR_RST_DISABLED     0
#define IR_RST_WAITING      1
#define IR_RST_TRIGGERED    2

//State variable
volatile uint8_t state;


void setup()
{
    DDRB = (0<<IR_IN) | 
           (1<<LED_OUT) | 
           (0<<RST_ENABLE_IN) | 
           (0<<RST_OUT); //set RST_OUT as input. This lets the reset line float undriven.

    PORTB |= (0<<RST_OUT);

    flashLed(4,500); // flash the led to show attiny has started

    state = IR_RST_WAITING; //start up with the IR reset enabled

    //enable IR_IN and RST_ENABLE_IN as pin change interrupt sources.
    PCMSK |= (1<<PCINT0) | (1<<PCINT2); 
    GIMSK |= (1<<PCIE);
    sei();
}

void loop()
{    
    switch(state)
    {
    case IR_RST_DISABLED:
    default:
        flashLed(2, 500);   //Signal that an IR pulse was received but ignored.
        break;

    case IR_RST_WAITING:
        flashLed(10, 500);  //Signal that IR Resets are now enabled
        break;

    case IR_RST_TRIGGERED:
        //Clear the state. No risk of race conditions, this takes just a single cycle. 
        state = IR_RST_DISABLED; 

        //Reboot the ESP
        DDRB |= (1<<RST_OUT);  //set RST_OUT as output. This drives the pin low, as the corresponding bit in PORTB is 0
        delayMicroseconds(240);
        DDRB &= ~(1<<RST_OUT); //set RST_OUT as input. This lets the reset line float undriven.

        flashLed(10, 50);   //Signal that the ESP was reset.
        break;
    }

    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    cli();               //disable interrupts so that the state won't change while we are falling asleep
    if(state != IR_RST_TRIGGERED)
    {
        sleep_enable();  //Set the sleep enable bit, allowing the sleep instruction to work.
        sei();           //Enable interrupts one cycle before falling asleep. If an interrupt source occurred after
        sleep_cpu();     //..disabling interrupts, the ISR will now trigger and abort the sleeping process
        sleep_disable(); //Clear the sleep enable bit, locking sleep functionality from accidential use
    }
    sei();               //enable interrupts back again and resume normal code execution.
}

ISR(PCINT0_vect)
{
    if(state == IR_RST_DISABLED)
    {
        if(PINB & (1 << RST_ENABLE_IN))
            state = IR_RST_WAITING; 
    }
    else
    {
        if(PINB & (1 << IR_IN))
            state = IR_RST_TRIGGERED; 
    }
}

void flashLed(int flashCount, int offTime)
{
    while (flashCount-- > 0) {
        PORTB |= (1<<LED_OUT);  //LED output high
        delay(50);
        PORTB &= ~(1<<LED_OUT); //LED output low
        delay(offTime);
    }
}

Si ya no desea que la función de parpadeo del LED, solo puede reemplazar toda la declaración del interruptor con un simple si:

if(state == IR_RST_TRIGGERED)
{
    //Clear the state. No risk of race conditions, this takes just a single cycle. 
    state = IR_RST_DISABLED; 

    //Reboot the ESP
    DDRB |= (1<<RST_OUT);  //set RST_OUT as output. This drives the pin low, as the corresponding bit in PORTB is 0
    delayMicroseconds(240);
    DDRB &= ~(1<<RST_OUT); //set RST_OUT as input. This lets the reset line float undriven.
}  

La eliminación de la funcionalidad de parpadeo también le permitiría implementar una depuración simple con el LED: alternar el estado del LED cuando se ejecuta una determinada pieza de código.
Por ejemplo, podría cambiar el LED cada vez que el pin RST_ENABLE_IN haya cambiado de estado, lo que le permitirá determinar si la línea de habilitación de reinicio alguna vez activa la interrupción en primer lugar

ISR(PCINT0_vect)
{
    if(PINB & (1 << RST_ENABLE_IN))
        PORTB ^= (1 << LED_OUT); //XOR the LED output with itself, toggling its state.
    ...