ATTiny45: Aufwachen mit PCINT klappt nicht

[Johannes (menschenskind)]

Hallo,

Ich schicke den µC in den PowerDownModus und will ihn danach durch einen 
PinChangeInterrupt von 2 Tastern(also entweder der eine oder der andere)
wieder aufwecken.
In der while-Schleife werden die Taster über Peter Daneggers 
Entprellroutine abgefragt, deswegen deaktiviere ich den PCINT sobald er 
ausgelöst wurde und aktiviere den erst kurz bevor es ans Schlafen geht.
Das "flag" wird beim langen Drücken einer Taste auf 0 gesetzt.
Und noch während ich die Taste gedrückt halte wird bereits die ISR 
aufgerufen und danach reagiert meine Schaltung auf keinen Tastendruck 
mehr.

Habt ihr ne Idee, woran das liegen könnte?
Danke
der Hannes

.
.
uint8_t flag = 1;

ISR( PCINT0_vect){
  GIMSK &= ~(1<<PCIE);
  flag ^=1;
}
int main(void){
.
.
  /**** Configure external Interrupts ****/
  //GIMSK |= (1<<PCIE); // Enable Pin Change Interrupt
  PCMSK |= (1<<PCINT1)|(1<<PCINT2);
  
  sei();    // Enable global interrupts  
.
.
  while(1){
.
.
    if( flag == 0){
      set_sleep_mode(SLEEP_MODE_PWR_DOWN);
      GIMSK |= (1<<PCIE);
      sleep_mode();
    }
   }
}

[Mick (Gast)]

Ich hab deinen Code nicht genau angeschaut. Aber das hier funktioniert:

bitSet(GIMSK, PCIE1);    //Turn on Pin Change interrupt
bitSet(PCMSK0, PCINT10); //Pin PCINT10

void sleepNow(){  
  cli();
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  sei();
  sleep_mode();
  sleep_disable();
}

ISR(PCINT1_vect){
  //flag handling
}

[Kirsch (Gast)]

Im Power-down Mode kann er ausschließlich durch ein Level-Interrupt an 
INT0 aufgeweckt werden

[Kirsch (Gast)]

Der Auszug aus dem Datenblatt ohne Transparents

[Kirsch (Gast)]

Ok, Pin Change Interrupt geht anscheinend auch im Powerdown an jedem 
Pin.

Was mir jetzt auffällt, "uint8_t flag" ist nicht volatile.

[Peter D. (peda)]

Ja, beim Sleep muß man sehr auf die genaue Reihenfolge achten.
Die wird im sleep_mode(); Macro aber nicht garantiert, daher führt das 
bei Benutzung regelmäßig zu Fehlfunktionen. Siehe auch der Warntext dazu 
in sleep.h.

Hier ein funktionierendes Beispiel, der 2. Beitrag enthält den 
verbesserten Code:
Beitrag "AVR Sleep Mode / Knight Rider"

[Johannes (menschenskind)]

Hallo Peter,
Das werde ich mal so in Deinem Beispielcode machen.

Allerdings hat es ja bereits schon funktioniert bei mir (mit 
sleepmode(); und set_sleep_mode();). Da hatte ich aber erst den 
LowLevelInterrupt INT0 benutzt und weil ich aber beide Taster zum 
Aufwecken nehmen will, auf PinChangeInterrupt gewechselt.

Ich schalte die "flag"-Variable um, wenn mit "get_key_long" ein langes 
Drücken festgestellt wurde.

[Johannes (menschenskind)]

Ok, in Deinem Thread hab ich noch gelesen, dass Du die 
"get_key_busy"-Abfrage machst. Evtl. ist das ja der Schlüssel.

[Johannes (menschenskind)]

Hallo Peter,

Also das Problem ist, sobald das lange Drücken des einen Tasters erkannt 
wird, dann geht der Controller schlafen. Wenn ich aber die Taste dann 
wieder loslasse, wacht er auf.
Müsste ich da in Deiner debounce.c noch was ändern?

Ich habe Deine Routine 1:1 übernommen. An einer anderen Stelle im Code 
verwende ich sie auch nochmal und da wird nach einem kurzen Tastendruck 
schlafen gegangen. Da gibt es keine Probleme.

[MWS (Gast)]

Toggle halt das Flag nicht
>  flag ^=1;
sondern setzte es in der ISR in einen definierten Zustand.
Wenn das Flag vor Aufruf der ISR durch irgendeinen Codeteil 0 wurde, 
dann ist's nachher <>0 und der Code in der While fühlt sich nicht mehr 
zuständig. Und dann ist halt Schluss, die ISR ist disabled.

Außerdem würde ich vor dem Enablen eines Interrupts
> GIMSK |= (1<<PCIE);
immer das entsprechende Interruptflag löschen, da sich der µC einen 
anstehenden Interrupt merkt und der kann noch von vorher, also nach dem 
Disablen des Interrupt stammen. Der wird dann sofort nach dem Enablen 
des entsprechenden Interrupts ausgeführt.

[Peter D. (peda)]

Johannes H. schrieb:
> Wenn ich aber die Taste dann
> wieder loslasse, wacht er auf.

Das macht ja nix und ist in meinem Beispiel auch so. Jede Flanke weckt 
auf.
Aber es wird ja keine Aktion ausgeführt, d.h. die Variable "stop" ändert 
sich nicht und damit wird sofort wieder "try_sleep" aufgerufen.

[Johannes (menschenskind)]

"flag" auf nen definierten Wert zu setzen hat's nicht gebracht.

@Peter: Aber was kann ich denn dann tun, um das Problem zu beheben? Im 
Kommentar zu get_key_busy steht doch "until key released".
Prellt der Taster eigentlich auch, wenn man ihn loslässt?

[Peter D. (peda)]

Der PCINT reagiert auf jede Flanke, also auch auf Prellen. Deshalb macht 
der bei mir nur das Aufwachen, sonst nichts. Laß ihn leer, das schont 
Nerven.

[Johannes (menschenskind)]

Hallo Peter,
Das Problem ist ja nicht das Aufwachen, sondern dass der µC schlafen 
geht WÄHREND die Taste noch runtergedrückt ist. Wenn ich die also 
loslasse wacht er ja gleich wieder auf.
Aber das Ziel ist ja dass er nach dem Loslassen immer noch schläft.

Als quick&dirty-Möglichkeit habe ich das jetzt so probiert, geht:

if(flag == 0){
      _delay_ms(500);
      try_sleep();
}

Aber das ist natürlich nicht failsafe...

[m.n. (Gast)]

Johannes H. schrieb:
> Aber das Ziel ist ja dass er nach dem Loslassen immer noch schläft.

Das geht nicht mit PCINT, da jede Flanke den µC aufweckt.

Hier noch ein Beispiel mit PCINT und zwei Tastern, die auch noch 
entprellt werden und selbst gedrückt keine hohe Stromaufnahme 
verursachen.
Beitrag "Re: EIN-AUS mit Taster per Interrupt, ATtiny25 o.ä."

Wichtig ist, daß nur beim Drücken einer Taste eine Aktion ausgelöst 
wird. Beim Loslassen wird der µC zwar kurz wach, legt sich aber gleich 
wieder schlafen.

[Peter D. (peda)]

Johannes H. schrieb:
> Als quick&dirty-Möglichkeit habe ich das jetzt so probiert, geht:

Ne, das ist grausam.
Ohne den kompletten Code, kann man natürlich nicht Deinen Fehler finden.
Machs doch so, wie in meinem Beispiel.
Das try_sleep() muß immer wieder aufgerufen werden, bis die Preller 
vorbei sind.

[Johannes (menschenskind)]

Hier mal der komplette Code. Eigentlich dachte ich, dass ich es genau so 
wie Du in Deinem Beispiel mache.
Wenn das flag 0 ist wird try_sleep aufgerufen.

#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include <avr/sleep.h>

#include "includes/config.h"
#include "includes/debounce.h"
#include "includes/light_ws2812.h"

struct cRGB LED_OUTPUT[1];
struct cRGB TEMP[1];

#define MODES 13
#define BRIGHTNESSES 6
#define PWM_MAX 255

volatile uint8_t flag = 1;

ISR( PCINT0_vect){
  flag = 1;

  GIFR = 0; // clear external interrupt flags
}

void try_sleep()
{
  if( get_key_busy( 1<<KEY1 ))
    return;          // still busy
  set_sleep_mode( SLEEP_MODE_PWR_DOWN);    // prepare power down
  GIMSK |= (1<<PCIE);      // awake interrupt on
  sleep_cpu();
  GIMSK &= ~(1<<PCIE);

}

int main(void){
  uint8_t mode_index = 1;
  uint8_t brightness_index = BRIGHTNESSES;  
  
  /**** Set Timer & Buttons for Debounce Functionality ****/
  KEY_DDR &= ~ALL_KEYS;
  KEY_PORT |= ALL_KEYS;

  TCCR0B = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK |= 1<<TOIE0;                   // enable timer interrupt  
  
  /**** Configure external Interrupts ****/
  PCMSK |= (1<<PCINT1)|(1<<PCINT2);
  
  
  /**** Power Reduction ****/
  PRR = (1<<PRUSI) | (1<<PRADC) | (1<<PRTIM1);
  
  sei();    // Enable global interrupts  
  
  initColors(); //can be deleted if direct initialization works
  
  TEMP[0]= colorStatic(0);
  ws2812_setleds(TEMP,1);  
  
  /************************************************************************/
  /* MAIN Action ;)                                                                     */
  /************************************************************************/
  while(1){
    
    if( get_key_short(1<<KEY0) ){
      if (mode_index == MODES)mode_index = 1;
      else mode_index += 1;            
    }
    
    if (get_key_long(1<<KEY0)) mode_index =0;
    
    if( get_key_short(1<<KEY1) ){
      if (brightness_index == 1)brightness_index = BRIGHTNESSES;
      else brightness_index -= 1;      
    }
    
    if (get_key_long(1<<KEY1)) flag ^= 1;
        
    switch (mode_index){
      case 0: LED_OUTPUT[0] = colorFade();break;
      case 1: if( flag == 1){
            LED_OUTPUT[0] = stroboscope();
             _delay_ms(10);
          }
          else LED_OUTPUT[0] = colorStatic(13);
          break;             
      case 2: LED_OUTPUT[0] = colorStatic(0); ws2812_setleds(LED_OUTPUT,1);try_sleep(); break;
      default: break;
    }
        
    if(mode_index >= 3){      
      if(flag == 1){
        LED_OUTPUT[0] = colorPulse(mode_index - 2);
        _delay_ms(20);
      }    
      else LED_OUTPUT[0] = colorStatic(mode_index-2);// Cycle colors starting from color "1" µC can be switched off here and woken up with interrupt
      
    }
    LED_OUTPUT[0].r  /= brightness_index;
    LED_OUTPUT[0].g  /= brightness_index;
    LED_OUTPUT[0].b  /= brightness_index;
    ws2812_setleds(LED_OUTPUT,1);
    
    if(flag == 0){
      _delay_ms(500);
      try_sleep();
    }
  }    
}

[Peter D. (peda)]

Johannes H. schrieb:
> Hier mal der komplette Code.

Schau Dir meinen PCINT an, der ist leer. Das Flag wird nur durch 
Tasteneingaben geändert.
Aber bei Dir setzt jede Flanke das Flag zurück. Das kann nicht gehen.

[Johannes (menschenskind)]

Hallo,
So bin jetzt wieder zurück aus dem Urlaub.

Ich hab's grad nochmal probiert: Auch wenn die ISR leer ist, wacht der 
µC nach dem Loslassen des Tasters gleich wieder auf.
Bzw. sogar wenn ich auf "get_key_long" triggere und den Taster die ganze 
Zeit gedrückt halte, geht der µC in den Schlafmodus und wacht im 
nächsten Moment wieder auf.

[Peter D. (peda)]

Johannes H. schrieb:
> Auch wenn die ISR leer ist, wacht der
> µC nach dem Loslassen des Tasters gleich wieder auf.

Du must das Programm natürlich so schreiben, daß er nur die 
Tasteneingabe  auswertet und immer wieder schlafen geht, solange das 
Flag gesetzt ist.
Der Name try_sleep wurde schon mit Absicht so gewählt, d.h. es muß nicht 
beim ersten Versuch (Flanke, Preller) klappen.
Genau so ist es in meinem Beispiel gelöst.

[Johannes (menschenskind)]

Hallo Peter,

Jetzt wird's misteriös bei mir.
Nachdem es partout nicht klappen wollte, hab ich die try_sleep mal so 
auskommentiert, dass der µC aus dem Schlafzustand nicht mehr aufwachen 
sollte:

void try_sleep()
{
  //if( get_key_busy( 1<<KEY1 )||get_key_busy(1<<KEY0) )
    //return;          // still busy
  set_sleep_mode( SLEEP_MODE_PWR_DOWN);    // prepare power down
  //GIMSK |= (1<<PCIE);      // awake interrupt on
  sleep_cpu();
  //GIMSK &= ~(1<<PCIE);

}

Aber: nach erneutem Drücken geht's einfach weiter.

Wie kann das sein? Das PCINT-Bit im GIMSK wird ja gar nicht gesetzt.

> Du must das Programm natürlich so schreiben, daß er nur die
> Tasteneingabe  auswertet und immer wieder schlafen geht, solange das
> Flag gesetzt ist.
Aber die Abfrage geht doch nach "if( flag == 0)" direkt zum 
"try_sleep"...
Allerding hast Du in Deiner Abfrage noch "get_key_short( 1<<KEY0 );". 
Das verstehe ich noch nicht ganz.

[Johannes (menschenskind)]

Hallo Peter,

Also zum einen hatte ich vergessen während der Initialisierung 
"sleep_enable" zu setzen (da hat "sleep_cpu" natürlich nichts 
bewirkt)...
Zum anderen kommt von "get_key_busy" IMMER nicht Null zurück, d.h. der 
µC wird nie schlafen geschickt.

Hast Du nen Idee, wie sich das beheben lässt?

[Johannes (menschenskind)]

Hallo Peter,

Ich hab noch mal in Deinem Knightriderbeispiel geschaut und mal den Code 
der initialen "get_key_busy" verwendet, also

return (~KEY_PIN | key_state) & key_mask;

Damit gibt die Funktion nun auch nur einen Wert ungleich 0 zurück, wenn 
der Schalter tatsächlich gedrückt wird, allerdings treten nun noch 
andere Problem auf. Ich vermute, weil die VerODERung mit "key_press" 
fehlt.

Kannst Du mir bitte nochmal helfen, warum Deine aktualisierte Variante

return ((KEY_PIN ^ key_state) | key_press) & key_mask;

 bei mir nicht funktioniert?

[Peter D. (peda)]

Stell mal einen compilierbaren Code (0 Warnings, 0 Errors) als Anhang 
(Zip) rein.
Mit Schnipselchen kann man keine Fehler suchen.

[Johannes (menschenskind)]

Hier, bitteschön.

[Johannes (menschenskind)]

Hallo Peter,

Ich wollte noch mal nachfragen, ob Du schon Zeit hattest mal in den Code 
reinzugucken.
Falls Dir das zu viel ist, kennst Du noch jemand anders aus dem Forum, 
der sich mit Deinem Code etwas auskennt? Bzw. würde ich einfach im 
zugehörigen Thread was posten.

[Peter D. (peda)]

Kannst Du mal das "nicht funktioniert" beschreiben.

Ich weiß nicht, wie lange Deine Mainloop dauert, es werden ja einige 
Unterfunktionen aufgerufen.
Die long/short Unterscheidung funktioniert nur dann einwandfrei, wenn 
die Mainloop immer kürzer als die short-Zeit dauert.
Wenn das nicht geht, muß man diese Unterscheidung mit in den 
Timerinterrupt legen.

[Johannes (menschenskind)]

Hallo Peter,
Naja, ich hab zwischen einigen Unterfunktionen 10 bzw. 20 ms delay 
eingebaut.

Die long/short Unterscheidung hat ja ohne Probleme funktioniert.
Durch die "get_key_busy"-Abfrage sind erst die Probleme gekommen, weil 
dessen Rückgabewert immer ungleich 0 ist und "try_sleep" dadurch gleich 
wieder verlassen wird.

[Johannes (menschenskind)]

Update:
Nachdem ich mich nun eingehender mit"get_key_busy" beschäftigt habe, 
habe ich diese nun so modifiziert:

return ((~KEY_PIN | key_state) | key_press) & key_mask;

Das scheint zu funktionieren.

[Peter D. (peda)]

So ich hab nochmal in Deinen Code geschaut.
Der Unterschied ist, daß ich das low-activ gleich in die Definition 
gepackt habe.

#define KEY_PIN      ~PINB    // Input low active

Damit ist dann KEY_PIN high aktiv.
Und damit ergibt

(KEY_PIN ^ key_state)

0, wenn der entprellte Zustand gleich dem (high)-Eingang ist, also das 
Entprellen abgeschlossen ist.
Ich finde das schöner, da dann das ~ nur einmal in der Definition stehen 
muß.

[Johannes (menschenskind)]

Ach daher kam's.
Also noch mal vielen Dank für Deine Analyse! :)