attiny13 aufwecken aus power down modus

[vlad (Gast)]

Hi, ich hab ein Problem mit dem Power Down Modus.

Ich krieg meinen Tiny da einfach nicht raus.

Meine schaltung:
attiny13 steuert ein paar leds.
An Pin6 (PB1 / INT0) hab ich einen einen Taster, der gegen Masse 
schaltet.
Der interne Pull-Up ist aktiviert.

Das schalter auslesen und ansteuern der LEDs klappt alles Prima.
Auch in den Power Down-Modus versetzen kann ich ihn:

  LED_OFF(LED_R);
  LED_OFF(LED_G);
  LED_OFF(LED_B);
  set_sleep_mode( SLEEP_MODE_PWR_DOWN); // aus avr/sleep.h
  GIMSK |= (1<<INT0);
  sleep_mode();                         // aus avr/sleep.h
  GIMSK &= ~(1<<INT0);

Vor dem Schlafen schicken aktiviere ich Int0.
Aber wenn ich dann auf den schalter drücke passiert rein gar nix, er 
bleibt aus.

Hoffe jemand hat ne idee

[Falk B. (falk)]

@  vlad (Gast)

>  set_sleep_mode( SLEEP_MODE_PWR_DOWN); // aus avr/sleep.h
>  GIMSK |= (1<<INT0);

Prüfe mal, ob du WIRKLICH den INT0 auf LOW LEVEL Interrupt konfiguriert 
hast.
Fallende/Steigende Flanke geht nicht!
Siehe Sleep Mode

MFG
Falk

[vlad (Gast)]

da ich das MCUCR register nirgends beschreibe, sollte das der Fall 
sein,werds heut abend noch mal explizit probieren.

Mir ist aber nicht ganz klar, was der Unterschied zwischen Low-Level und 
fallende Flanke ist.
Beides ist active-low. LowLevel wird nur immer wieder aufgerufen, 
solange der pin auf masse liegt, oder wie? wie ist da die wiederholrate? 
sobald er aus der ISR raus ist?

Meine schaltung ist aber nicht das Problem?

[... .. (docean)]

Hast du auch ein sei() verbaut?

[vlad (Gast)]

sa sei() is drin, da ich den timer benutze

[vlad (Gast)]

>// externer Interrupt INT0
>
>// Die Interruptroutine kann leer sein, ABER sie muss existieren!
>// Sonst springt der AVR nach dem Aufwachen zum Reset, weil kein sinnvoller
>// Interruptvektor eingetragen ist!
>
>ISR(INT0_vect) {
>}

Bei mir ist die ISR leer.
kann es sein, dass der Compiler ne leere Routine wegoptimiert?

[Peter D. (peda)]

vlad schrieb:
> Aber wenn ich dann auf den schalter drücke passiert rein gar nix, er
> bleibt aus.

Man könnte jetzt versuchen, Dir alle Würmer aus der Nase zu ziehen.
Du könntest aber auch ganz profan nen compilierfähigen Code (*.c) als 
Anhang posten, geht deutlich schneller.


Allgemein kann man nur die sleep.h zitieren:
"the sleep_mode() macro might cause race conditions in some situations"

Oder deutlicher: Das sleep_mode() gehört verboten!


Peter

[vlad (Gast)]

So habe ein Problem gefunden Hatte tatsächlich vergessen die interupts 
wieder zu aktivieren.

Nu hab ich aber ein neues Problem.

Hab das ganze auf beigefügten Code reduziert (hoffe habe nix vergessen 
reinzukopieren)

wenn ich das cli weglasse, geht alles, außer dass mir hin und wieder der 
Timer dazwischenfunkt und die leds wieder anschaltet.
um das zu verhindern, will ich nach dem Tastendruck bis zum sleep_cpu 
die Interupts sperren.
jedoch wacht der tiny sofort wieder auf.

Weiß da jemand rat?

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <util/delay.h>
#include "mystdtypes.h"  // uint8, ...



#define LED_OFF(i) (PORTB &= ~(1<<(i)))
#define LED_ON(i)  (PORTB |=  (1<<(i)))

/* ========================================================================*/
/* ======================   global constants ==============================*/
/* ========================================================================*/
#define LED_R PIN0
#define LED_G PIN4
#define LED_B PIN2

#define COL_R 0
#define COL_G 1
#define COL_B 2

#define SWITCH PIN1

/* ========================================================================*/
/* =========================   global data ================================*/
/* ========================================================================*/
static uint8 g_fpwmCounter = 0;
static volatile uint8 g_rgbDutycycles[3] = {0,0,0};

/* ========================================================================*/
/* ========================================================================*/

//call this routine to initialize all peripherals
static inline void init_devices(void)
{
  DDRB  = (1<<LED_R) | (1<<LED_G) | (1<<LED_B); // BEWARE! writes all BITS
  PORTB |= (1<<SWITCH); // activate pullup
  TCCR0B |= (0<<CS02) | (0<<CS01) | (1<<CS00); // timer prescaler to 1
  TIMSK0 |= (1<<TOIE0); // enable timer interrupt;

  ACSR |= (1<<ACD);
  sei();
}

ISR(INT0_vect){}

ISR(TIM0_OVF_vect){
  ++g_fpwmCounter;

  if( g_fpwmCounter < g_rgbDutycycles[COL_R]  ) {
    LED_ON(LED_R);
  }else{
    LED_OFF(LED_R);
  }
  if( g_fpwmCounter < g_rgbDutycycles[COL_G]  ) {
    LED_ON(LED_G);
  }else{
    LED_OFF(LED_G);
  }
  if( g_fpwmCounter < g_rgbDutycycles[COL_B]  ) {
    LED_ON(LED_B);
  }else{
    LED_OFF(LED_B);
  }
}


static inline void powerDown(void)
{
  set_sleep_mode( SLEEP_MODE_PWR_DOWN);
  LED_OFF(LED_R);
  LED_OFF(LED_G);
  LED_OFF(LED_B);
  GIMSK |= (1<<INT0);  // enable int0
  sleep_enable();
  sei();
  sleep_cpu();
  sleep_disable();
  GIMSK &= ~(1<<INT0); // disable int0
}



/**********************************************************************/
int main (void) 
{ 
  _delay_loop_2(0);
  init_devices();
  _delay_loop_2(0);

  while(1)
  {
    g_rgbDutycycles[COL_R] = 128;
    g_rgbDutycycles[COL_G] =   0;
    g_rgbDutycycles[COL_B] = 255;

    while(( PINB & (1<<SWITCH)));

    //cli(); // <-- wenn das aktiv ist, dann geht er sofort aus dem power down raus

    _delay_loop_2(0); // nur um sicher zu gehen, das der schalter nicht prellt.
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);

    powerDown();
    
    _delay_loop_2(0); // nur um sicher zu gehen, das der schalter nicht prellt.
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
    _delay_loop_2(0);
  }
}

[Peter D. (peda)]

vlad schrieb:
>

>     while(( PINB & (1<<SWITCH)));
> 
>     //cli(); // <-- wenn das aktiv ist, dann geht er sofort aus dem
> power down raus
>

Ist doch richtig, denn der Pin ist ja low, sonst wäre ja das while() 
nicht verlassen worden.

Die Delays kannst Du in der Pfeife rauchen.
Tastendruck entprellen und Flanke erkennen sieht anders aus.


Mach Dir mal nen PAP, wie das Sleep gestartet und wie es wieder 
verlassen werden soll.
Beides mit dem Zustand Pin = low kann nicht gehen. Dann machst Du nur 
beides schnell hintereinander.
Es müssen unterschiedliche Bedingungen sein.


Peter


P.S.:
Wenn Du schon Delays benutzt, was stört Dich daran, es lesbar zu machen, 
d.h. die Zeit direkt in µs oder ms anzugeben?

[(Gast) (Gast)]

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Sleep-Modes
http://www.nongnu.org/avr-libc/user-manual/index.html
Beitrag "AVR - Absturz aufgrund zu vieler Interrupts?"

[vlad (Gast)]

>Ist doch richtig, denn der Pin ist ja low, sonst wäre ja das while()
>nicht verlassen worden.

Was hat das mit dem cli zu tun?
es läuft kein anderer Int als der Timer und der Int0, der später gesetzt 
wird.

die delays sind bloß für des minimalbeispiel da, in meinem Programm sind 
die Tasten "ordentlich" entprellt


> Mach Dir mal nen PAP, wie das Sleep gestartet und wie es wieder
> verlassen werden soll.
Was bitte ist PAP

das sleep soll beginnen, wenn taste lang gedrückt wurde.
dann wird ein blinksignal ausgegeben (da ist genug zeit die Taste 
loszulassen)
dann power down.

bei erneuten tastendruck soll er wieder aufwachen.

das einschläfern und aufwecken funktioniert auch, bis auf das 
Blink-signal , da hier der Timer dazwischen funkt und die LEDs 
verstellt.
deaktiviere ich die Interrupts, dann sehe ich das Blinken aber er läuft 
direkt weiter aus dem PowerDwon raus, obwohl der Taster schon seit ner 
sekunde nicht mehr gedrückt wird.

folgendes kommt dem orignal näher:

int main (void) 
{ 
  _delay_loop_2(0);
  init_devices();
  _delay_loop_2(0);

  g_rgbDutycycles[COL_R] = 128;
  g_rgbDutycycles[COL_G] =   0;
  g_rgbDutycycles[COL_B] = 255;

  while(1)
  { uint8 i=0;
    while(( PINB & (1<<SWITCH)));
    //cli();   // <- hier ist das komische verhalten
    LED_OFF(LED_R);
    LED_OFF(LED_G);
    LED_OFF(LED_B);
    for(;i<100;++i){
      PINB |= (1<<LED_R); // TOGGLE
      _delay_ms(20);
    }

    powerDown();
    _delay_ms(1000);
  }
}

[Peter D. (peda)]

vlad schrieb:

> Was bitte ist PAP

Programm-Ablauf-Plan

> das sleep soll beginnen, wenn taste lang gedrückt wurde.

Schön das endlich zu wissen.
Jedoch sehe ich nirgends Code für Langerkennung.

> folgendes kommt dem orignal näher:

Das ist nicht schön, daß Du uns so verscheißerst.
Mit nur "näher kommen" ist keinem gedient.
Schreibe einen Code, lasse ihn laufen und erst dann poste Fragen, die 
auch auf diesen getesteten Code passen!

Wenn Du immer nur irgendwas ausgedachtes hinschreibst, brauchst Du Dich 
nicht zu wundern, daß die Antworten nicht auf Deinen unbekannten Code 
passen.


Peter

[vlad (Gast)]

>Jedoch sehe ich nirgends Code für Langerkennung.
die Langerkennung funktioniert und ist nicht teil des Problems deswegen 
ist sie in der Kurzvariante nicht drin.

>Schreibe einen Code, lasse ihn laufen und erst dann poste Fragen, die
>auch auf diesen getesteten Code passen!

der Code, den ich gepostet habe ist der, an dem ich grad rumprobiere.
Bei ihm tritt das selbe Problem auf, wie in meiner eigendlichen 
Anwendung.
Warum also willst du den gesammten Code (der Tiny13 ist bei 95%), wenns 
in dieser Minimalvariante genauso ersichtlich ist?


Die neue Variante habe ich nur gepostet, damit ersichtlihc ist, dass es 
kein Problem des Tasters ist, der noch gedrückt ist, wenn in den 
sleep-mode gegangen wird, ansonsten ist die Problematik die selbe, wie 
bei der ersten Code-Variante.
Wenn du dir den Code angeschaut oder gar ausprobiert hättest (mehr als 
ne LED und ein Taster ist dafür ja nicht nötig), wüstest du das

Ich habe alles was ich poste getestet.
Das einzige was an meinem Code anders ist, ist, dass ich nicht 
angesprungene Funktionen entfernt habe.

[Peter D. (peda)]

vlad schrieb:
> Die neue Variante habe ich nur gepostet, damit ersichtlihc ist, dass es
> kein Problem des Tasters ist, der noch gedrückt ist, wenn in den
> sleep-mode gegangen wird

Du mußt ihn nach dem Drücken innerhalb von 2s loslassen (100*20ms 
Warteschleife), dann sollte es funktionieren. Es ist also höchstens ne 
Kurzdruckerkennung.

> Wenn du dir den Code angeschaut

Das habe ich, sonst hätte ich ja nicht erkannt, daß da garkeine 
Langerkennung drin ist.
Das Du eine Routine postest, die nicht das macht, was Du erklärst, ist 
zumindest verwirrend, auch wenn da nicht der Fehler ist.


Wenn Dich der Timerinterrupt stört, dann deaktiviere ihn einfach vor dem 
Sleep.
Deaktiviere alle Interrupts, die nicht zum Aufwachen benötigt werden.
Dem Sleep ist es nämlich wurscht, welcher Interrupt es beendet.


Peter

[vlad (Gast)]

> Du mußt ihn nach dem Drücken innerhalb von 2s loslassen (100*20ms
> Warteschleife), dann sollte es funktionieren.
es funktioniert ebend nicht, bzw nur, wenn ich die Interupts NICHT 
deaktiviere.

Wenn das cli() weg ist, gehts, aber der timer fummelt halt bei dem 
Blink-signal dazwischen, dafür bleibt der tiny aber im power down.
wenn das cli() da ist, mag er nicht schlafen.

>Dem Sleep ist es nämlich wurscht, welcher Interrupt es beendet.

nur der int0 (und der wachhund, den ich nicht hab) kann den aufwecken

[Peter D. (peda)]

So, ich habs mal selber ausprobiert.
Es funktioniert alles bestens, wenn man ne ordentliche Entprellroutine 
nimmt.

Die Taste wechselt zwischen Schlafen und Wachen hin und her. Das 
Schlafen darf natürlich erst nach Loslassen erfolgen.
Und hier der komplette Code:

#include <avr\io.h>
#include <avr\interrupt.h>
#include <avr\sleep.h>

//           Access bits like variables:
struct bits {
  uint8_t b0:1;
  uint8_t b1:1;
  uint8_t b2:1;
  uint8_t b3:1;
  uint8_t b4:1;
  uint8_t b5:1;
  uint8_t b6:1;
  uint8_t b7:1;
} __attribute__((__packed__));

#define SBIT_(port,pin) ((*(volatile struct bits*)&port).b##pin)
#define SBIT(x,y)  SBIT_(x,y)

int main( void ) __attribute__((OS_main));  // avoid push in main


#define RED          SBIT( PORTB, 2 )
#define RED_DDR      SBIT( DDRB,  2 )
#define GREEN        SBIT( PORTB, 3 )
#define GREEN_DDR    SBIT( DDRB,  3 )
#define BLUE         SBIT( PORTB, 4 )
#define BLUE_DDR     SBIT( DDRB,  4 )
#define KEY0_PULLUP  SBIT( PORTB, 1 )

#define KEY_PIN    PINB
#define KEY0       PB1

#define LED_OFF    1
#define LED_ON    0


uint8_t key_state;        // debounced and inverted key state:
                          // bit = 1: key pressed
uint8_t key_press;        // key press detect

uint8_t pwm_red, pwm_green, pwm_blue, pwm_cycle;
uint8_t t_flag;


ISR( INT0_vect )
{
}


ISR( TIM0_OVF_vect )          // 9.6MHz / 256 = 37.5kHz
{
  if( --pwm_cycle == 0 )
    t_flag = 1;               // / 256 = 146Hz (7ms)
  if( pwm_red > pwm_cycle )
    RED = LED_ON;
  else
    RED = LED_OFF;
  if( pwm_green > pwm_cycle )
    GREEN = LED_ON;
  else
    GREEN = LED_OFF;
  if( pwm_blue > pwm_cycle )
    BLUE = LED_ON;
  else
    BLUE = LED_OFF;
}


void init( void )
{
  RED_DDR = 1;
  GREEN_DDR = 1;
  BLUE_DDR = 1;
  KEY0_PULLUP = 1;

  TCCR0A = 0;
  TCCR0B = 1<<CS00;          // XTAL / 1
  TIMSK0 = 1<<TOIE0;

  ACSR = 1<<ACD;             // disable analog comparator

  set_sleep_mode( SLEEP_MODE_PWR_DOWN);    // prepare sleep
  sleep_enable();
}


void go_asleep( void )
{
  TIMSK0 = 0;               // other interrupts off
  RED = LED_OFF;
  GREEN = LED_OFF;
  BLUE = LED_OFF;
  GIMSK = 1<<INT0;          // awake interrupt on
  sleep_cpu();
  GIMSK = 0;
  TIMSK0 = 1<<TOIE0;
}


void key_debounce( void )        // called every 7ms from main
{
  static uint8_t ct0, ct1;
  uint8_t i;

  i = key_state ^ ~KEY_PIN;      // key changed ?
  ct0 = ~( ct0 & i );            // reset or count ct0
  ct1 = ct0 ^ (ct1 & i);         // reset or count ct1
  i &= ct0 & ct1;                // count until roll over ?
  key_state ^= i;                // then toggle debounced state
  key_press |= key_state & i;    // 0->1: key press detect
}


uint8_t get_key_press( uint8_t key_mask )
{
  key_mask &= key_press;                        // read key(s)
  key_press ^= key_mask;                        // clear key(s)
  return key_mask;
}


int main( void )
{
  uint8_t sleep_on = 0;

  init();
  sei();

  pwm_red = 255;
  pwm_green = 64;
  pwm_blue = 16;

  for(;;){
    if( t_flag ){
      t_flag = 0;
      key_debounce();
    }
    if( get_key_press( 1<<KEY0 )){
      sleep_on = !sleep_on;        // toggle sleep/awake
    }
    if( sleep_on &&                // sleep on
      !(key_state & 1<<KEY0) &&    // and key state released
      (KEY_PIN & 1<<KEY0)){        // and key released
      go_asleep();
    }
  }
}

Peter

[vlad (Gast)]

es liegt nicht an der Entprellung!
wenn ich anstatt des cli() auch nur den timer deactiviere dann gehts bei 
mir auch. Das ist zwar ein Workaround, aber mich interessiert dennoch wo 
das Problem seinen Ursprung hat.



Mach mal nach der Erkennung des Tastendrucks ein
cli() anstatt den Timer-Int abzustellen.
direkt vor dem sleep muss ein sei()

[vlad (Gast)]

>wenn ich anstatt des cli() auch nur den timer deactiviere dann gehts bei
>mir auch
wobei das nicht am timer liegt.
Es wird damit ja nur verhindert, dass der Timer die LEDs verstellt.
Es geht ja auch mit aktiviertem timer und er bleibt im sleep, nur sieht 
man das Blinken nicht


die cli/sei müssen irgendwelche seiteneffecte haben, die ich übersehe.

[Peter D. (peda)]

vlad schrieb:
> es liegt nicht an der Entprellung!

Aber die Entprellung macht das Ganze erst richtig testbar.

Außerdem bewirkt sie, daß die Schaltung nicht gleich durch Störimpulse 
wieder aufwacht (z.B. Einschalten einer Leuchtstofflampe in der Nähe).
Der AVR wacht kurz auf, macht die Entprellung, merkt, es ist nur ne 
Störung und geht sofort wieder schlafen.


> Mach mal nach der Erkennung des Tastendrucks ein
> cli() anstatt den Timer-Int abzustellen.
> direkt vor dem sleep muss ein sei()

Warum sollte ich, es ist falsch.
Wie schon gesagt, jeder freigegebene Interrupt verläßt das Sleep.

Das Power-Down verhindert nur, daß der Timer weiterzählt und einen 
weiteren Interrupt erzeugt.
Aber das interessiert nicht, da Du durch das cli() den Timerinterrupt am 
Ausführen gehindert hast.
Das Interrupt-Pending-Bit des Timers ist also schon längst gesetzt und 
reißt Dich natürlich nach dem sei() sofort wieder aus dem Sleep raus.


Peter

[vlad (Gast)]

>Wie schon gesagt, jeder freigegebene Interrupt verläßt das Sleep.
Das ist falsch!
Der Timer kann den AVR nicht aus dem Schlaf holen!
Das kann nur der INT0 und der Watchdog.
Datenblatt Tabelle 7-1 Seite 30

[Peter D. (peda)]

vlad schrieb:
>>Wie schon gesagt, jeder freigegebene Interrupt verläßt das Sleep.
> Das ist falsch!

[Goldwaagemodus an]
Wie schon gesagt, jeder freigegebene pending Interrupt verläßt das 
Sleep.
[Goldwaagemodus aus]

Nun zufrieden?

> Der Timer kann den AVR nicht aus dem Schlaf holen!

Er kann nur keinen neuen Interrupt auslösen, da er nicht weiter zählt.

Die Interruptlogik ist im Power-Down voll aktiv und damit verläßt jeder 
freigegebene pending Interrupt das Sleep. Das Sleep dauert dann genau 
einen CPU-Zyklus.
Man könnte auch sagen, es wird ja kein Sleep ausgeführt, es wird wie ein 
NOP ausgeführt.

Stelle Dir das einfach mal in Hardware vor:
Das Signal zum Interrupteinsprung liegt parallel auch an der 
Aufwachschaltung an.
Es gibt keine extra Schaltung mit ANDs und ORs von jeder Interruptquelle 
und jedem Freigabebit speziell für die Sleep-Schaltung.


> Das kann nur der INT0 und der Watchdog.
> Datenblatt Tabelle 7-1 Seite 30

Darum geht es überhaupt nicht.
Es geht um beim Sleep-Befehl bereits anhängige Interrupts.


Peter

[vlad (Gast)]

>[Goldwaagemodus an]
>Wie schon gesagt, jeder freigegebene pending Interrupt verläßt das
>Sleep.
>[Goldwaagemodus aus]

Du hast scheinbar Recht. Steht aber nicht im Datenblatt.
Ist jetzt auch egal, es funktioniert jetzt alles.

Ich danke für eure Hilfe,
Gruß,
Vlad

[Peter D. (peda)]

vlad schrieb:
> Du hast scheinbar Recht. Steht aber nicht im Datenblatt.

Das Datenblatt schreiben auch nur Menschen, muß also nicht immer 100% 
verständlich sein.

Indirekt steht es doch drin:
Table 7-1 Seite 30 sagt, daß die "Clock Domain" CLK_IO abgeschaltet 
wird, d.h. der Timer zählt nicht weiter.
Daß damit auch sein Interrupt Pending Flag gelöscht wird, steht aber 
nirgends.


Peter

[vlad (Gast)]

>Das Datenblatt schreiben auch nur Menschen, muß also nicht immer 100%
>verständlich sein.

Hab auch schon deutlich schlimmere Datenblätter gesehen ;)

[Lokus P. (derschatten)]

Ich habe dieses Beispiel hier ausgegraben weil es ganu das machen soll 
was ich benötigen würde.
Mit einer Taste den Sleep-Modus EIN/AUS zu schalten.

Was mir jedoch hier fehlt ist, wo wird denn der Interrupt-PIN zum 
aufwecken definiert?
Also der PCMSK0?

[Lokus P. (derschatten)]

Also ich habe mein program damit jetzt fast so zum laufen bekommen wie 
ich es gern haben möchte.
Jedoch sind noch 2 seltsame Verhalten:

.) Ich kann den AVR in den Schlafmodus schicken aber mit der gleichen 
taste nicht mehr aufwecken
.) Bei jedem Tastendruck des Encoders (#define TASTER  (1 << PB2)) wird 
der AVR aufgeweckt (und nur dann) und beginnt den main-Vorgang 
abzuarbeiten.

[Lokus P. (derschatten)]

HELP PLEASE!
Verzweifel!

[Lokus P. (derschatten)]

Es läuft fast.
Das einzige Problem das ich noch habe ist das "schlafen()" beim 
Tastendruck 2 mal durchlaufen wird.

Jemand eine Idee?

[Lokus P. (derschatten)]

Nochmal nur auf das notwendigste beschränkt, damits übersichtlicher ist.
Jedoch selber Effekt.