Missed Interrupt Problem mit Attiny85

Sie gehen bei jeder Iteration von bedingungslos schlafen loop(). Das ist nicht das, was Sie wollen. So wie Ihr Code jetzt ist, verpassen Sie jedes Weckereignis, das auftritt, während Ihr normaler Programmcode ausgeführt wird.

Ihr Code verbringt die meiste Zeit damit, innen zu verzögern flash(). Und der Controller geht schlafen, nachdem flash()er fertig ist. Stets. Dies bedeutet, dass jedes Mal, wenn ein Aufwachereignis auftritt, während die LED blinkt, kein Aufwachen verursacht wird. Das liegt nur daran, dass der Interrupt aufgetreten ist und gewartet wurde, bevor Sie schlafen gegangen sind.

Sehen Sie sich das Beispiel in der avr-libc-Dokumentation hier an .

Ihr Code sollte so aussehen:

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
  }

}

Der Punkt hier ist, dass wir alle Interrupts deaktivieren, während wir prüfen, ob wir schlafen gehen wollen. Auf diese Weise stellen wir sicher, dass kein Interrupt passieren kann, nachdem wir überprüft haben, aber bevor wir tatsächlich schlafen. Entscheidend ist jedoch, dass wir kurz vor dem Einschlafen wieder Interrupts aktivieren, sonst werden wir nie wieder geweckt.

Außerdem hat @jms Recht mit der Aussage, dass Sie beim Zurücksetzen Ihrer Flaggen eine andere potenzielle Rennbedingung haben, also fügen Sie dort auch einige cli/sei hinzu.

set_sleep_mode(SLEEP_MODE_PWR_DOWN);hineingehen kann setup(). Und wenn Sie kein Raumschiff steuern, gilt dasselbe für sleep_enable();, während Sie es sleep_disable();vollständig weglassen.

(*) Der oben als "sicher" bezeichnete Code ist nicht absolut kugelsicher, da der Compiler theoretisch während der Optimierung entscheiden könnte, einige Anweisungen neu anzuordnen, sodass sie sei()möglicherweise sleep_cpu()nicht in direkter Reihenfolge stehen. Überprüfen Sie zur Sicherheit den generierten Assembler-Code ( gcc -save-temps) oder schreiben Sie die erforderlichen Anweisungen einfach selbst als Inline-Assembler. (Kann so einfach sein wie asm volatile (" sei \r\n sleep \r\n " :::);.)

Ich bin mir ziemlich sicher, dass dies ein klassisches Parallelitätsproblem ist, das dadurch entsteht, dass Sie die beiden Flags nach dem Zurücksetzen des ESP löschen.

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 

Das ATtiny funktioniert manchmal wie beabsichtigt, wenn das ESP lange genug braucht, um seine Sache zu erledigen, bevor es den Interrupt auslöst.

Die Lösung ist einfach, löschen Sie die Flags, bevor Sie das ESP zurücksetzen.

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 
}

BEARBEITEN:

Wie @JimmyB feststellte, gibt es sowohl im Code der ursprünglichen Frage als auch in meiner ursprünglichen Antwort ein zweites Versehen. Wenn ESP-IR-Resets aktiviert sind und ein IR-Impuls eintrifft , während der ATtiny wach ist , geht der ATtiny in den Ruhezustand, ohne den AVR zurückzusetzen, und es dauert einen zweiten, überflüssigen IR-Impuls, um tatsächlich einen Reset des ESP auszulösen.

Um dies zu beheben, sollte das ResetEsp-Flag kurz vor dem Einschlafen erneut überprüft werden (während Interrupts deaktiviert sind), und die allerletzte Anweisung vor der Sleep-Anweisung sollte die Interrupts wieder aktivieren. Auf diese Weise wird, wenn ein IR-Impuls ankommt, während das resetEsp-Flag erneut überprüft wird, der Schlafmodus-Übergang durch den anstehenden Interrupt abgebrochen.

Dieser Code sollte auch dieses Problem beheben.

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
    }
}  

BEARBEITEN 2:

Hier ist der vollständige Code einer Implementierung, die auf einer einzelnen Zustandsvariablen basiert. Ich habe auch modifiziert, wie die ESP-Reset-Leitung angesteuert wird: Jetzt wird die Reset-Leitung normalerweise ungetrieben schwebend gelassen und kurz auf Masse gebracht, wenn ein Reset befohlen wird.

#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);
    }
}

Wenn Sie die LED-Blinkfunktion nicht mehr möchten, können Sie einfach die gesamte switch-Anweisung durch ein einfaches if ersetzen:

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.
}  

Wenn Sie die Blinkfunktion entfernen, können Sie auch ein einfaches Debugging mit der LED implementieren: Schalten Sie den LED-Status um, wenn ein bestimmter Codeabschnitt ausgeführt wird.
Beispielsweise könnten Sie die LED jedes Mal umschalten, wenn der RST_ENABLE_IN-Pin jemals den Zustand ändert, sodass Sie feststellen können, ob die Reset-Enable-Leitung überhaupt jemals den Interrupt auslöst

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