Taster - externen Interrupt Problem

[daniel san (Gast)]

Hi,

vorab was das Programm tun sollte.

Wird er Blaue Taster (INT0, PD2) gedrückt wird die enstprechende ISR 
aufgerufen dort soll immer ein Flag erhöht werden.

Beim 1. Tastendruck soll "menue" auf 1 gesetzt werden, so dass in der 
Main in der switch-case der Part "Set_Time" ausgeführt wird, toogle dort 
Testweise einen Portpin PD0 um zu sehen, das er auch da reinspringt.

Nur leider tut das Programm mir nicht den gefallen.
Ich weiß das der Taster prellt, und habe deswegen in der ISR die ext. 
Interrupts abgeschaltet, die externen INTpins als Ausgang geschaltet und 
zusätzlich die entsprechenden Flags gelöscht, da sonst ja wieder ein 
neuer ISR Aufruf erfolgt.

Nur klappt das nicht und ich weiß nicht was ich falsch mache.

Prellen hardewaremäßig beheben geht leider nicht mehr.

Ich möchte das gerne mit Interrupts lösen.

Ich hoffe mir kann jemand von euch helfen.

Ich danke euch!

Hardware:
ATTiny2313, läuft mit 1MHz

Code:

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

#ifndef F_CPU
#define F_CPU 1000000      // processor clock frequency
#warning kein F_CPU definiert
#endif

//****************************************************
/*  Pinbelegung:

   Output:
  PB5 - A
  PB4 - B
  PB3 - DP
  PB2 - C
  PB1 - D
  PB0 - E
  PB6 - F
  PB7 - G

  PD0 - Relais
  PD1 - Summer

  PD6 - min  
  PD5 - sek_1
  PD4 - sek_2
  
  Input:
  (auf fallende Flanke triggern - Taster wird gedrückt)
  PD3(INT1) - tast_rot
  PD2(INT0) - tast_bl  
  
  Clock:
  CKSEL = 01000 = Internal 8MHz RC
  CKDIV = 8

  Internal 8MHz / 8div = 1MHz

*/
//****************************************************

// 7-Segment-Anzeige 0 - 9:
//0 a,b,c,d,e,f
#define NULL 0b01110111
//1 a,b,c
#define EINS 0b00010100 
//2 a,b,d,e,g
#define ZWEI 0b10110011
//3 a,b,c,d,g
#define DREI 0b10110110
//4 b,c,f,g
#define VIER 0b11010100
//5 a,c,d,f,g
#define FUENF 0b11100110
//6 a,c,d,e,f,g
#define SECHS 0b11100111
//7 a,b,c,g
#define SIEBEN 0b00110100
//8 a,b,c,d,e,f,g
#define ACHT 0b11110111
//9 a,b,c,d,f,g
#define NEUN 0b11110110
// - - -
#define STRICH 0b10000000

//****************************************************

uint16_t cnt;
uint8_t flag;
uint8_t menue;

uint8_t t1;
uint8_t t2;
uint8_t t3;

uint8_t sek;
uint8_t min;
uint8_t sek1;
uint8_t sek2;
int zahlen[11]={NULL,EINS,ZWEI,DREI,VIER,FUENF,SECHS,SIEBEN,ACHT,NEUN,STRICH};

enum mode {SET_TIME, START, STOP};
  
enum mode menue;

ISR(INT0_vect)
//Taster Blau >> SET_TIME
{
  flag++;

  if(flag==1)
  {
    menue++;

    GIMSK &= ~( (1<<INT1) | (1<<INT0) ); //disable ext ints
    DDRD |= (1<<PD3) | (1<<PD2); //Portpins als Ausgang wegen Prellvorgang

  }


  EIFR |= (1<<INTF1) | (1<<INTF0); //ext. int flag löschen

}

ISR(INT1_vect) 
//Taster Rot einstellen des Wertes für die 3 Segmentanzeigen (Min(einstellig), Sek (2stellig))
{
 //todo...
}

ISR(TIMER1_COMPA_vect)
// wird jede 1sek. aufgerufen
{
  
  sek++;

  if(sek==60)
  {
    min++;
    sek=0;
  }
  else if(min>9)
  {
    min=0;
  }

}

ISR(TIMER0_COMPA_vect)
// wird alle 4ms aufgerufen für die 7-seg Anzeigen
{
  cnt++;

  if(cnt==1)
  {
    PORTB=0;
    PORTD &= ~(1<<PD4);
    PORTD &= ~(1<<PD5);
    _delay_us(2);

    PORTB = zahlen[t1];
    PORTB |= (1<<PB3);
    PORTD |= (1<<PD6);
  }
  else if(cnt==2)
  {
    PORTD &= ~(1<<PD6);
    PORTD &= ~(1<<PD4);
    _delay_us(2);

    PORTB = zahlen[t2];
    PORTD |= (1<<PD5);
  }
  else if(cnt==3)
  {
    PORTD &= ~(1<<PD5);
    PORTD &= ~(1<<PD6);
    _delay_us(2);

    PORTB = zahlen[t3];
    PORTD |= (1<<PD4);
  }
  else if(cnt>3)
  {
    cnt=0;
  }

} 

int main(void)
{
  cnt=0;
  min=0;
  sek1=0;
  sek2=0;
  t1=0,t2=0,t3=0;
  flag=0;
  

  //----------------------------------------------------------
  //PORTB/D configuration
  //----------------------------------------------------------

  DDRB = 0xff; //PORTB Output
  PORTB = 0x00;

  DDRD |= (1<<PD6) | (1<<PD5) | (1<<PD4) | (1<<PD1) | (1<<PD0); //PD6-4,1-0 Out    
  DDRD &= ~( (1<<PD3) | (1<<PD2) );

  PORTD &= ~((1<<PD3) | (1<<PD2)); //Pull-Up deaktivieren, falls gesetzt
  PORTD = 0x00;

  _delay_us(2);

  PORTD &= ~((1<<PD6) | (1<<PD5) | (1<<PD4));
  _delay_us(2);

  //----------------------------------------------------------
  //Timer configuration
  //----------------------------------------------------------

  //Timer1 - CTC-Mode Top=OCR1A
  TCCR1B |= (1<<WGM12);

  //Timer1 - top-value
  OCR1A = 15625; //1sec

  //internal clock | div64, gleichzeit counter starten!
  TCCR1B |= (1<<CS11) | (1<<CS10);

  //Timer0 - CTC-Mode Top=OCR0A
  TCCR0A |= (1<<WGM01);
  
  //div64 >> 1MHz/1024=976,5625Hz
  TCCR0B |= (1<<CS02) | (1<<CS00); 
  
  //Timer0 - top-value
  OCR0A = 4; // 156 ca. 10ms | 24 ca. 24ms

  //enable Timer 0 output compare A match interrupt
  //TIMSK |= (1<<OCIE0A) | (1<<OCIE1A);
  TIMSK |= (1<<OCIE0A);
  
  //----------------------------------------------------------
  //external interrupt configuration (taster)
  //----------------------------------------------------------

  //INT1, INT0 any change + enable
  MCUCR |= (1<<ISC11) | (1<<ISC01);
  GIMSK |= (1<<INT1) | (1<<INT0);
  
  //----------------------------------------------------------

  menue=-1;

  sei();  //enable global ints

  while(1)
  {

    switch (menue)
    {
      case 0:
        
        PORTD |= (1<<PD0);
        _delay_ms(100);
        PORTD &= ~(1<<PD0);

        t1=2;
        t2=2;
        t3=2;
          
        EIFR |= (1<<INTF1) | (1<<INTF0);
        GIMSK |= (1<<INT1) | (1<<INT0); //enable ext ints
        DDRD &= ~( (1<<PD3) | (1<<PD2) ); //Tasterpins als Input


      break;

      case 1:
      break;

      case 2:
      break;

      default:
      break;
    }
    

  }

}

[Karl H. (kbuchegg)]

daniel san schrieb:

>
> Prellen hardewaremäßig beheben geht leider nicht mehr.
>
> Ich möchte das gerne mit Interrupts lösen.

Warum? Es gibt keinen Grund dafür! (So wie es meistens keinen Grund gibt 
um Taster mittels Interrupt auszuwerten. Aus irgendeinem Grund hält sich 
dieser Mythos beständig und ist nicht auszurotten. Der einzige Grund für 
Interrupts mit Tastern wäre wenn der µC aus dem Tiefschlaf geholt werden 
muss. Aber ansonsten braucht kein Mensch dafür Interrupts. Das macht 
alles nur noch komplizierter)

Du hast mit

ISR(TIMER0_COMPA_vect)

einen perfekten Platz um eine softwaremässige Entprellung einzubauen

Entprellung
ganz unten, die C Routinen (das Timer Vorladen lässt du einfach weg)

Edit: Und bevor du fragst - mit diesen Entprell-Routinen kriegst du 
einen automatischen Autorepeat frei Haus mitgeliefert. Gerade bei 
Einstell-Dingen wie deinen, ist das sehr praktisch. Einfach auf den 
Knopf drücken und die Zahl wird gemächlich ganz von alleine größer 
solange du den Taster gedrückt hältst.

[daniel san (Gast)]

Hi

Karl Heinz Buchegger schrieb:


> Du hast mit
>
> ISR(TIMER0_COMPA_vect)
>
> einen perfekten Platz um eine softwaremässige Entprellung einzubauen
>
> Entprellung
> ganz unten, die C Routinen

hi ja ich kenne diese Seite,

sprichst du von der Komfortroutine?

ich finde die Entprellung vom Dannegger aufwendig und kompliziert.


Hatte mir das schon mal angeguckt, aber der Code ist verwirrend 
geschrieben, finde ich. Da wird in einer Funktion noch drei weitere 
Funktionen aufgerufen.

Verstanden habe ich den noch nicht...

Bevor ich das Problem auf ein anderes verlagere, würde ich trotzdem 
gerne wissen was bei mir falsch ist. Vielleicht seh ich dann ein was 
einfacher ist ;)

[Karl H. (kbuchegg)]

daniel san schrieb:
> Hi
>
> Karl Heinz Buchegger schrieb:
>
>
>> Du hast mit
>>
>> ISR(TIMER0_COMPA_vect)
>>
>> einen perfekten Platz um eine softwaremässige Entprellung einzubauen
>>
>> Entprellung
>> ganz unten, die C Routinen
>
> hi ja ich kenne diese Seite,
>
> sprichst du von der Komfortroutine?
>
> ich finde die Entprellung vom Dannegger aufwendig und kompliziert.

Sie ist überhaupt nicht aufwendig.
Über kompliziert kann man streiten. Ja, sie ist nicht leicht zu 
durchschauen. Das macht allerdings in diesem Falle nichts. Dafür 
funktioniert sie einfach zu gut. Dieses Stück Software ist eines der 
wenigen, von dem ich sagen würde: Egal ob du sie verstehst oder nicht - 
nutze sie.

> Hatte mir das schon mal angeguckt, aber der Code ist verwirrend
> geschrieben, finde ich. Da wird in einer Funktion noch drei weitere
> Funktionen aufgerufen.

Das zentrale Element ist das hier

  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
 
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }

das kommt in deine ISR ans Ende mit rein.

Und das wars dann bei dir auch schon.

Die #define davor übernimmst du noch und passt sie an deine 
Gegebenheiten an#

#define KEY_DDR         DDRD
#define KEY_PORT        PORTD
#define KEY_PIN         PIND
#define KEY_BLUE        2
#define KEY_RED         3
#define ALL_KEYS        (1<<KEY_BLUE | 1<<KEY_RED)
 
#define REPEAT_MASK     (1<<KEY_RED)          // repeat: nur bei Rot
#define REPEAT_START    50                    // after 500ms
#define REPEAT_NEXT     20                    // every 200ms

und die Funktionen übernimmst du so wie sie sind

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}

Fertig ist deine Entprellung. (Portpins noch auf Eingang und 
gegebenenfalls einen Pullup dafür einschalten wenn du keinen externen 
hast)

In der mainloop heißt es dann

  while(1)
  {
    // TAste blau gedrückt: Einstellmodus
    if( get_key_press( 1<<KEY_BLUE ) ) {
      menu++;
      if( menu == 4 )
        menu = 0;
    }

    // Taste rot gedrückt: Zeit weiterschalten
    // dabei ist auch Autorepeat erlaubt
    if( get_key_press( 1 <<KEY_RED ) || get_key_rpt( 1<<KEY_RED ) ) {
      // je nach Einstellmodus
      // menu gleich 0 ist normal: keine Einstellung
      if( menu == 1 )
        t1++;
      else if( menu == 2 )
        t2++;
      else if( menu == 3 )
        t3++;
      }
    }
  }

einfacher gehts wirklich nimmer diese Funktionen zu verwenden.

Eine Sache auf 3 Minuten und du hast erstklassig funktionierende Tasten.

[daniel san (Gast)]

Ok danke dir, bin gerade dabei den Code vom Dannegger nachzuvollziehen.

Bei Fragen melde ich mich hier nochmal.

[Karl H. (kbuchegg)]

daniel san schrieb:


> Bevor ich das Problem auf ein anderes verlagere, würde ich trotzdem
> gerne wissen was bei mir falsch ist. Vielleicht seh ich dann ein was
> einfacher ist ;)

Das müsste man jetzt genauer analysieren.

[Karl H. (kbuchegg)]

Deine ISR sieht dann so aus (deine multiplext nämlich 1:4 anstelle von 
1:3)

ISR(TIMER0_COMPA_vect)
// wird alle 4ms aufgerufen für die 7-seg Anzeigen + Entprellung
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;

  PORTB = 0;
  PORTD &= ~(1<<PD4);
  PORTD &= ~(1<<PD5);
  PORTD &= ~(1<<PD6);

  cnt++;
  if( cnt == 3 )
    cnt = 0;

  switch( cnt ) {
    case 0:
      PORTB = zahlen[t1] | (1<<PB3);
      PORTD |= (1<<PD6);
      break;

    case 1:
      PORTB = zahlen[t2];
      PORTD |= (1<<PD5);
      break;

    case 2:
      PORTB = zahlen[t3];
      PORTD |= (1<<PD4);
      break;
  }

  // Tastenpins einlesen und entprellen
  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
 
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }
}

[daniel san (Gast)]

Hi ich hab das nun soweit angepasst.

Leider wird die untere if-Abfrage aus der main nie bearbeitet , kann den 
blauen Taster so oft drücken wie ich will :(

Es sollte beim betätigen des blauen Tasters menue um 1 erhöht werden und 
anschließend sollen nacheinanchder die Anzeigen - Werte eingestellt 
werden.

1. Taster blau betätigt:

case 1:

i=1
Anzeige:
| - | 0 | 0 |

Taster rot Zahl einstellen 0-9

Solange warten bis mit Taster blau bestätigt

i=2
Anzeige:
| 2 . | - | 0

wieder die gleiche Prozedur

i=3
Anzeige:
| 2. | 1 | - |

...

if(get_key_press(1<<KEY_BLUE)) // wird nie ausgeführt auch wenn blauer Taster mehrmals gedrückt
{
   menue++;

   PORTD |= (1<<PD0);

   if(menue>3)
   {
  menue=0;
   }
}

Hier der gesamte Code:

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

#ifndef F_CPU
#define F_CPU 1000000      // processor clock frequency
#warning kein F_CPU definiert
#endif

//****************************************************
/*  Pinbelegung:

   Output:
  PB5 - A
  PB4 - B
  PB3 - DP
  PB2 - C
  PB1 - D
  PB0 - E
  PB6 - F
  PB7 - G

  PD0 - Relais
  PD1 - Summer

  PD6 - min  
  PD5 - sek_1
  PD4 - sek_2
  
  Input:
  (auf fallende Flanke triggern - Taster wird gedrückt)
  PD3(INT1) - tast_rot
  PD2(INT0) - tast_bl  
  
  Clock:
  CKSEL = 01000 = Internal 8MHz RC
  CKDIV = 8

  Internal 8MHz / 8div = 1MHz

*/
//****************************************************

// 7-Segment-Anzeige 0 - 9:
//0 a,b,c,d,e,f
#define NULL 0b01110111
//1 a,b,c
#define EINS 0b00010100 
//2 a,b,d,e,g
#define ZWEI 0b10110011
//3 a,b,c,d,g
#define DREI 0b10110110
//4 b,c,f,g
#define VIER 0b11010100
//5 a,c,d,f,g
#define FUENF 0b11100110
//6 a,c,d,e,f,g
#define SECHS 0b11100111
//7 a,b,c,g
#define SIEBEN 0b00110100
//8 a,b,c,d,e,f,g
#define ACHT 0b11110111
//9 a,b,c,d,f,g
#define NEUN 0b11110110
// - - -
#define STRICH 0b10000000

//****************************************************

#define KEY_DDR         DDRD
#define KEY_PORT        PORTD
#define KEY_PIN         PIND
#define KEY_BLUE        2
#define KEY_RED         3
#define ALL_KEYS        (1<<KEY_BLUE | 1<<KEY_RED)
 
#define REPEAT_MASK     (1<<KEY_RED)            // repeat: nur bei Rot
#define REPEAT_START    50                      // after 500ms
#define REPEAT_NEXT     20                      // every 200ms

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

uint16_t cnt;
uint8_t flag;

uint8_t t1;
uint8_t t2;
uint8_t t3;

uint8_t sek;
uint8_t min;
uint8_t sek1;
uint8_t sek2;
int zahlen[11]={NULL,EINS,ZWEI,DREI,VIER,FUENF,SECHS,SIEBEN,ACHT,NEUN,STRICH};

//enum mode {SET_TIME=1, START=2, STOP=3};
  
//enum mode menue;

ISR(TIMER1_COMPA_vect)
// wird jede 1sek. aufgerufen
{
  
  sek++;

  if(sek==60)
  {
    min++;
    sek=0;
  }
  else if(min>9)
  {
    min=0;
  }

}

ISR(TIMER0_COMPA_vect)
// wird alle 4ms aufgerufen für 7-seg Anzeige
{
  static uint8_t ct0, ct1, rpt;
    uint8_t i;

  cnt++;

  if(cnt==1)
  {
    PORTB=0;
    PORTD &= ~(1<<PD4);
    PORTD &= ~(1<<PD5);
    _delay_us(2);

    PORTB = zahlen[min];
    PORTB |= (1<<PB3);
    PORTD |= (1<<PD6);
  }
  else if(cnt==2)
  {
    PORTD &= ~(1<<PD6);
    PORTD &= ~(1<<PD4);
    _delay_us(2);

    PORTB = zahlen[sek1];
    PORTD |= (1<<PD5);
  }
  else if(cnt==3)
  {
    PORTD &= ~(1<<PD5);
    PORTD &= ~(1<<PD6);
    _delay_us(2);

    PORTB = zahlen[sek2];
    PORTD |= (1<<PD4);
  }
  else if(cnt>3)
  {
    cnt=0;
  }

  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
 
    if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
  {
      rpt = REPEAT_START;                          // start delay
  }

    if( --rpt == 0 )
  {
      rpt = REPEAT_NEXT;                            // repeat delay
      key_rpt |= key_state & REPEAT_MASK;
  }

} 

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////

int main(void)
{
  cnt=0;
  min=0;
  sek1=0;
  sek2=0;
  t1=0,t2=0,t3=0;
  flag=0;

  uint8_t menue;
  

  //----------------------------------------------------------
  //PORTB/D configuration
  //----------------------------------------------------------

  DDRB = 0xff; //PORTB Output
  PORTB = 0x00;

  DDRD |= (1<<PD6) | (1<<PD5) | (1<<PD4) | (1<<PD1) | (1<<PD0); //PD6-4,1-0 Out    
  DDRD &= ~( (1<<PD3) | (1<<PD2) );

  PORTD &= ~((1<<PD3) | (1<<PD2)); //Pull-Up deaktivieren, falls gesetzt
  PORTD = 0x00;

  _delay_us(2);

  PORTD &= ~((1<<PD6) | (1<<PD5) | (1<<PD4));
  _delay_us(2);

  //----------------------------------------------------------
  //Timer configuration
  //----------------------------------------------------------

  //Timer1 - CTC-Mode Top=OCR1A
  TCCR1B |= (1<<WGM12);

  //Timer1 - top-value
  OCR1A = 15625; //1sec

  //internal clock | div64, gleichzeit counter starten!
  TCCR1B |= (1<<CS11) | (1<<CS10);

  //Timer0 - CTC-Mode Top=OCR0A
  TCCR0A |= (1<<WGM01);
  
  //div64 >> 1MHz/1024=976,5625Hz
  TCCR0B |= (1<<CS02) | (1<<CS00); 
  
  //Timer0 - top-value
  OCR0A = 4; // 4

  //enable Timer 0 output compare A match interrupt
  //TIMSK |= (1<<OCIE0A) | (1<<OCIE1A);
  TIMSK |= (1<<OCIE0A);
  
  //----------------------------------------------------------
  //external interrupt configuration (taster)
  //----------------------------------------------------------

  //INT1, INT0 any change + enable
//  MCUCR |= (1<<ISC11) | (1<<ISC01);
//  GIMSK |= (1<<INT1) | (1<<INT0);
  
  //----------------------------------------------------------

  menue=0;

  sei();  //enable global ints

  while(1)
  {

    switch (menue)
    {
      case 1:
        
        PORTD &= ~(1<<PD0);        

        //t1=10;
        //t2=10;
        //t3=10;

        for(int i=1;i<=3;i++)
        {
                      
          if(i==1)
          {
            t1=10;  //Strich 1.Anzeige          

            while(!get_key_press(1<<KEY_BLUE))
            {
              if( get_key_press(1<<KEY_RED) || get_key_rpt(1<<KEY_RED) )
              {
                t1++;
                if(t1>9)
                {
                  t1=0;
                }
              }
            }
          }
          else if(i==2)
          {
            t2=10;  //Strich 2.Anzeige

            while(!get_key_press(1<<KEY_BLUE))
            {
              if( get_key_press(1<<KEY_RED) || get_key_rpt(1<<KEY_RED) )
              {
                t2++;
                if(t2>9)
                {
                  t2=0;
                }
              }
            }
          }
          else if(i==3)
          {
            
            t3=10;  //Strich 3.Anzeige
            
            while(!get_key_press(1<<KEY_BLUE))
            {
              if( get_key_press(1<<KEY_RED) || get_key_rpt(1<<KEY_RED) )
              {
                t3++;
                if(t3>9)
                {
                  t3=0;
                }
              }
            }
          }

        }

      break;

      case 2:
      break;

      case 3:
      break;

      default:
      break;
    }

    if(get_key_press(1<<KEY_BLUE))
    {
      menue++;

      PORTD |= (1<<PD0);

      if(menue>3)
      {
        menue=0;
      }
    }    

  }

}

[Karl H. (kbuchegg)]

>    switch (menue)
>    {
>      case 1:

Wie wird die variable menu jemals wieder 0?

Dein Programm ist viel zu kompliziert und du verlierst dich jetzt in der 
Komplexität.

Du brauchst eine Variation davon

  while(1)
  {
    // TAste blau gedrückt: Einstellmodus
    if( get_key_press( 1<<KEY_BLUE ) ) {
      menu++;
      if( menu == 4 )
        menu = 0;
    }

    // Taste rot gedrückt: Zeit weiterschalten
    // dabei ist auch Autorepeat erlaubt
    if( get_key_press( 1 <<KEY_RED ) || get_key_rpt( 1<<KEY_RED ) ) {
      // je nach Einstellmodus
      // menu gleich 0 ist normal: keine Einstellung
      if( menu == 1 )
        t1++;
      else if( menu == 2 )
        t2++;
      else if( menu == 3 )
        t3++;
      }
    }
  }

d.h. es gibt nur eine einzige while Schleife und das ist die 
Hauptschleife.
Innerhalb derer wickelst du alles ab. Hör auf in Dingen wie "solange 
Taste gedrückt" zu denken. Dein Programm ist in einem Zustand 
(ausgedrückt durch die Variable menu) und Tastendrücke
a) verändern diesen Zustand
b) lösen abhängig vom Zustand Aktionen aus.

Wenn du haben willst, dass nach einem Druck auf blau eine der Stellen 
einen Strich anzeigt, dann schreib das auch so

  while(1)
  {
    // TAste blau gedrückt: Einstellmodus
    if( get_key_press( 1<<KEY_BLUE ) ) {
      menu++;
      if( menu == 4 )
        menu = 0;

      if( menu == 1 )
        t1 = 10;
      else if( menu == 2 )
        t2 = 10;
      else if( menu == 3 )
        t3 = 10;
    }

    // Taste rot gedrückt: Zeit weiterschalten
    // dabei ist auch Autorepeat erlaubt
    if( get_key_press( 1 <<KEY_RED ) || get_key_rpt( 1<<KEY_RED ) ) {
      // je nach Einstellmodus
      // menu gleich 0 ist normal: keine Einstellung
      if( menu == 1 )
        t1++;
      else if( menu == 2 )
        t2++;
      else if( menu == 3 )
        t3++;
      }
    }
  }

Deine ganze for-Schleifen Konstruktion ist viel zu kompliziert.

   for( i = 0; i < 3; ++i ) {   // gewöhn dir an, dass in C bei 0 begonnen
                                // wird zu zählen!
     if( i == 0 )
       mach was A

     else if( i == 1 )
       mach was B

     else if( i == 2 )
       mach was C
  }

ist doch eine komplizierte Umschreibung für

    mach was A
    mach was B
    mach was C

dazu brauchst du keine Schleife, wenn du dann erst recht wieder in der 
Schleife je nach Schleifenvariable unterschiedliche "mach was" ausführen 
lassen willst. Da kannst du einfach die nacheinander abzuarbeitenden 
Teile auch untereinander schreiben und in genau der Reihenfolge werden 
sie dann abgearbeitet.

[Karl H. (kbuchegg)]

>   PORTD &= ~((1<<PD3) | (1<<PD2)); //Pull-Up deaktivieren, falls gesetzt
>  PORTD = 0x00;

Wie sind deine Taster verschaltet?
Hast du externe Pullups?

[daniel san (Gast)]

Hi,

Karl Heinz Buchegger schrieb:
>>             while(!get_key_press(1<<KEY_BLUE))
>
> Du kannst das nicht so machen.
> Denn der blaue Taster ist ja nur einmal gedrückt.
> Das war ja der Sinn der ganzen Übung.

ok das geht bei der Funktion nicht, stimmt.

Aber das Problem ist ja was anderes er führt ja nichtmal das aus

if( get_key_press( 1<<KEY_BLUE ) ) {
      menu++;
      if( menu == 4 )
        menu = 0;

      if( menu == 1 )
        t1 = 10;
      else if( menu == 2 )
        t2 = 10;
      else if( menu == 3 )
        t3 = 10;
    }

hab deine Main mal 1zu1 wie im obigen Beitrag drüber kopiert und 
ausprobiert, bei keinem einzigen Tastendruck des blauen Tasters wird in 
die if-anweisung ausgeführt.

[daniel san (Gast)]

Hi ja externe Pullups

[daniel san (Gast)]

DDRB = 0xff; //PORTB Output
PORTB = 0x00;

DDRD |= (1<<PD6) | (1<<PD5) | (1<<PD4) | (1<<PD1) | (1<<PD0); //PD6-4,1-0 Out

PD3 und PD2 sind ja im Anfangszustand automatisch auf 0 eingestellt, 
laut DB

[daniel san (Gast)]

Die Funktion von Dannegger geht ja vom invertierten Zustand also Pullups 
aus.

Bei tasterbetätigung liegt eine 0 am PIN-Port

[Karl H. (kbuchegg)]

daniel san schrieb:

>
> Aber das Problem ist ja was anderes er führt ja nichtmal das aus

Ja, hab ich zu spät mitgekriegt.

[Karl H. (kbuchegg)]

> Hi ja externe Pullups

ok.
laut deinem Kommentar schalten die Tasten nach Masse. Stimmt das auch?

[Karl H. (kbuchegg)]

daniel san schrieb:
> Die Funktion von Dannegger geht ja vom invertierten Zustand also Pullups
> aus.
>
> Bei tasterbetätigung liegt eine 0 am PIN-Port

Ja. Ist richtig.
So werden Tasten auch üblicherweise beschaltet. Dann braucht man nämlich 
keinen externen Pullup (und drumm frag ich dich dauernd danach)

Funktionieren deine Tasten anders rum?

[daniel san (Gast)]

Messe direkt im Pin-Port PD3 bzw. PD2 .

Bei unbetätigtem Taster, ein High Signal gemessen.

Sobald ich diesen betätige wird auf Masse gezogen.

[Karl H. (kbuchegg)]

daniel san schrieb:
> Messe direkt im Pin-Port PD3 bzw. PD2 .
>
> Bei unbetätigtem Taster, ein High Signal gemessen.
>
> Sobald ich diesen betätige wird auf Masse gezogen.

OK.
Ist schon mal die halbe Miete.

Lass mich nochmal den Code durchgehen. Ich seh mal zu, dass ich hier bei 
mir was nachstellen kann.

> ausprobiert, bei keinem einzigen Tastendruck des blauen Tasters wird in
> die if-anweisung ausgeführt.

OK.
dann solltest du erst mal testen, ob deine Taster überhaupt 
funktionieren.
(Deine Anzeige ist ja da, d.h. der Interrupt wird aufgerufen)


In der Zwischenzeit kannst du ja mal verifizieren, ob deine Tasten auch 
programmtechnisch funktionieren.

#include <avr/io.h>

int main()
{
  DDRB = 0xFF;
  DDRD = ( 1 << PD5 );

  PORTB = 0x00;
  PORTD = ( 1<<PD5 );

  while( 1 ) {

    if( PIND & ( 1 << PD3 ) )
      PORTB = 0xFF;
    else
      PORTB = 0x00;
  }
}

auf die Taste latschen und auf deiner 7-Segment müsste 1 Segment 
komplett aufleuchten.

[daniel san (Gast)]

Hi ich hab mal die Taster mal ans Oszi gehängt um zu gucken ob die 
Prellen, sollte doch im 200us Bereich liegen?

Ich sehe da kein Prellen...

Also nackten Pull-up mit R=10k aufgebaut und auf fallende Flanke 
getriggert.

[daniel san (Gast)]

So einen Taster nutze ich, kann mir nicht vorstellen das diese prellfrei 
sind.

http://www.csd-electronics.de/de/index.htm

Best.Nr.: 35-TREB01

Teste gleich ma dein Code zwecks Tastert-test

[Karl H. (kbuchegg)]

daniel san schrieb:
> Hi ich hab mal die Taster mal ans Oszi gehängt um zu gucken ob die
> Prellen, sollte doch im 200us Bereich liegen?
>
> Ich sehe da kein Prellen...

Sie werden Prellen.
Wenn nicht heute dann in 2 Wochen oder 2 Monaten.

[daniel san (Gast)]

ALso Taster geht, die 2.Anzeige die an PD5 hängt geht aus.

Ich vermute dadruch das mein Taster nicht so dolle prellt das ganze von 
Dannegger nicht funktioniert. ..Vermutung

[Karl H. (kbuchegg)]

daniel san schrieb:
> ALso Taster geht, die 2.Anzeige die an PD5 hängt geht aus.
>
> Ich vermute dadruch das mein Taster nicht so dolle prellt das ganze von
> Dannegger nicht funktioniert. ..Vermutung

Nein.
:-)

Der Code geht natürlich auch, wenn die Taster nicht prellen :-)

[Klaus D. (kolisson)]

Karl Heinz Buchegger schrieb:
> Der Code geht natürlich auch, wenn die Taster nicht prellen :-)

Das mach doch richtig Lust, demnächst mal wieder einen Beitrag zu 
schreiben.
Der Titel könnte lauten:
"Habe fertigen Hexcode mit Entprellroutine von Autor: peter dannegger,
.. kann Software nicht ändern , suche entsprechende Prelltasten,
.... wo bestellen ?"

Das wäre doch schön , oder ?

Gruss Klaus

[daniel san (Gast)]

Hm warum es nicht funktioniert ..hmmmm.

Taster gehen ja, habs getestet, sonst ist nicht viel an meinem Programm 
dran.

Worin sich mein Code unterscheid, ISR wird alle 4ms statt 10ms 
aufgerufen und folgende Zeile habe ich nicht

TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 
10ms

aber daran wirds wohl nicht liegen.

[Hannes L. (hannes)]

Nur gut, dass es Assembler gibt, und Peters Entprellroutine in ASM...
Da versteht man, was man tut, da macht das Programmieren Spaß...

Duck & weg...

...

[Karl H. (kbuchegg)]

OK. Ich musste auf einem Mega16 testen und dann ins blaue auf einen 2313 
umschreiben

Probier das mal

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h> 

#ifndef F_CPU
#define F_CPU 1000000      // processor clock frequency
#warning kein F_CPU definiert
#endif

// 7-Segment-Anzeige 0 - 9:
//0 a,b,c,d,e,f
#define NULL 0b01110111
//1 a,b,c
#define EINS 0b00010100 
//2 a,b,d,e,g
#define ZWEI 0b10110011
//3 a,b,c,d,g
#define DREI 0b10110110
//4 b,c,f,g
#define VIER 0b11010100
//5 a,c,d,f,g
#define FUENF 0b11100110
//6 a,c,d,e,f,g
#define SECHS 0b11100111
//7 a,b,c,g
#define SIEBEN 0b00110100
//8 a,b,c,d,e,f,g
#define ACHT 0b11110111
//9 a,b,c,d,f,g
#define NEUN 0b11110110
// - - -
#define STRICH 0b10000000

//****************************************************

#define KEY_DDR         DDRD
#define KEY_PORT        PORTD
#define KEY_PIN         PIND
#define KEY_BLUE        2
#define KEY_RED         3
#define ALL_KEYS        (1<<KEY_BLUE | 1<<KEY_RED)
 
#define REPEAT_MASK     (1<<KEY_RED)            // repeat: nur bei Rot
#define REPEAT_START    50                      // after 500ms
#define REPEAT_NEXT     20                      // every 200ms

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

int zahlen[11]={NULL,EINS,ZWEI,DREI,VIER,FUENF,SECHS,SIEBEN,ACHT,NEUN,STRICH};


ISR(TIMER0_COMPA_vect)
// wird alle 4ms aufgerufen für 7-seg Anzeige
{
  static uint8_t ct0, ct1, rpt;
  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

  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
  {
      rpt = REPEAT_START;                          // start delay
  }

  if( --rpt == 0 )
  {
      rpt = REPEAT_NEXT;                            // repeat delay
      key_rpt |= key_state & REPEAT_MASK;
  }
} 

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////

int main(void)
{
  uint8_t cnt = 0;

  DDRB = 0xFF;
  DDRD = ( 1 << PD5 );

  PORTB = 0xFF;
  PORTD = ( 1<<PD5 ) | ( 1 << KEY_RED ) | ( 1 << KEY_BLUE );

  TCCR0A |= (1<<WGM01);
  OCR0A = 4; // 4
  TIMSK |= (1<<OCIE0A);
  TCCR0B |= (1<<CS02) | (1<<CS00); 

  sei();  //enable global ints

  while( 1 ) {

    if( get_key_press( 1 << KEY_RED ) ) {
      cnt++;
      if( cnt == 10 )
        cnt = 0;
    }

    if( get_key_press( 1 << KEY_BLUE ) ) {
      cnt--;
      if( cnt == 0xFF )
        cnt = 9;
    }

    PORTB = zahlen[ cnt ];
  }
}

Dieselbe mittlere Anzeige zeigt wieder eine Zahl an und durch Druck auf 
Rot bzw. Blau kann sie erhöht/verringert werden.

[Karl H. (kbuchegg)]

Wenn dieses Testprogramm funktioniert (sollte es eigentlich), dann 
arbeite damit weiter und bau es in die Richtung aus, die du haben 
willst.

Irgendwo in deinem Programm hast du dich verfranst, ich seh aber nichts 
augenfälliges. Das ist mir schon etwas zu verworren und ausserdem muss 
ich gleich weg. Ich bin aber morgen vormittag wieder da.

Zwischendurch immer wieder testen! Nicht zuviel ungetesteten Code auf 
einmal.

[daniel san (Gast)]

Hi danke dir!

Mit deinen Programm klappt es... warum bei mir nicht .

Morgen werde ich das mal mit meinem vergleichen.

Bis dahin n schönen Abend noch!

[daniel san (Gast)]

Hi also hab auf Basis deines Codes etwas erweitert.

Da passiert es schon wieder. Wenn ich den unteren Codeabschnitt in die 
ISR packe die alle 4ms angesprungen wird, wird wie schon zuvor nicht 
mehr auf Tastendruck reagiert.......

ISR(TIMER0_COMPA_vect)
// wird alle 4ms aufgerufen für 7-seg Anzeige
{
  static uint8_t ct0, ct1, rpt;
  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

  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
  {
      rpt = REPEAT_START;                          // start delay
  }

  if( --rpt == 0 )
  {
      rpt = REPEAT_NEXT;                            // repeat delay
      key_rpt |= key_state & REPEAT_MASK;
  }

  cnt++;

  if(cnt==1)
  {
    PORTB=0;
    PORTD &= ~(1<<PD4);
    PORTD &= ~(1<<PD5);
   // _delay_us(2);

    PORTB = zahlen[t1];
    PORTB |= (1<<PB3);
    PORTD |= (1<<PD6);
  }
  else if(cnt==2)
  {
    PORTD &= ~(1<<PD6);
    PORTD &= ~(1<<PD4);
    //_delay_us(2);

    PORTB = zahlen[t2];
    PORTD |= (1<<PD5);
  }
  else if(cnt==3)
  {
    PORTD &= ~(1<<PD5);
    PORTD &= ~(1<<PD6);
   // _delay_us(2);

    PORTB = zahlen[t3];
    PORTD |= (1<<PD4);
  }
  else if(cnt>3)
  {
    cnt=0;
  }
}

Ich habe in der while nur cnt durch t1 ersetzt, sonst nichts geändert.

Ich versteh nicht woran es liegen soll...., muss was mit dem 
TIMER0_COMPA_vect ISR zu tun haben da ich dort nur mein Codeabschnitt 
zur aktualisierung der Anzeigen reingepackt hab.

Hier der gesamte Code:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h> 

#ifndef F_CPU
#define F_CPU 1000000      // processor clock frequency
#warning kein F_CPU definiert
#endif

// 7-Segment-Anzeige 0 - 9:
//0 a,b,c,d,e,f
#define NULL 0b01110111
//1 a,b,c
#define EINS 0b00010100 
//2 a,b,d,e,g
#define ZWEI 0b10110011
//3 a,b,c,d,g
#define DREI 0b10110110
//4 b,c,f,g
#define VIER 0b11010100
//5 a,c,d,f,g
#define FUENF 0b11100110
//6 a,c,d,e,f,g
#define SECHS 0b11100111
//7 a,b,c,g
#define SIEBEN 0b00110100
//8 a,b,c,d,e,f,g
#define ACHT 0b11110111
//9 a,b,c,d,f,g
#define NEUN 0b11110110
// - - -
#define STRICH 0b10000000

//****************************************************

#define KEY_DDR         DDRD
#define KEY_PORT        PORTD
#define KEY_PIN         PIND
#define KEY_BLUE        2
#define KEY_RED         3
#define ALL_KEYS        (1<<KEY_BLUE | 1<<KEY_RED)
 
#define REPEAT_MASK     (1<<KEY_RED)            // repeat: nur bei Rot
#define REPEAT_START    50                      // after 500ms
#define REPEAT_NEXT     20                      // every 200ms

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

int zahlen[11]={NULL,EINS,ZWEI,DREI,VIER,FUENF,SECHS,SIEBEN,ACHT,NEUN,STRICH};

uint8_t t1,t2,t3;
uint8_t cnt;


ISR(TIMER0_COMPA_vect)
// wird alle 4ms aufgerufen für 7-seg Anzeige
{
  static uint8_t ct0, ct1, rpt;
  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

  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
  {
      rpt = REPEAT_START;                          // start delay
  }

  if( --rpt == 0 )
  {
      rpt = REPEAT_NEXT;                            // repeat delay
      key_rpt |= key_state & REPEAT_MASK;
  }

  cnt++;

  if(cnt==1)
  {
    PORTB=0;
    PORTD &= ~(1<<PD4);
    PORTD &= ~(1<<PD5);
   // _delay_us(2);

    PORTB = zahlen[t1];
    PORTB |= (1<<PB3);
    PORTD |= (1<<PD6);
  }
  else if(cnt==2)
  {
    PORTD &= ~(1<<PD6);
    PORTD &= ~(1<<PD4);
    //_delay_us(2);

    PORTB = zahlen[t2];
    PORTD |= (1<<PD5);
  }
  else if(cnt==3)
  {
    PORTD &= ~(1<<PD5);
    PORTD &= ~(1<<PD6);
   // _delay_us(2);

    PORTB = zahlen[t3];
    PORTD |= (1<<PD4);
  }
  else if(cnt>3)
  {
    cnt=0;
  }
} 

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////

int main(void)
{
  cnt = 0;
  t1=0,t2=0,t3=0;

  DDRB = 0xFF;

  PORTB = 0xFF;
  PORTD |= ( 1<<PD6 ) | ( 1 << PD5 ) | ( 1 << PD4 );

  TCCR0A |= (1<<WGM01);
  OCR0A = 4; // 4
  TIMSK |= (1<<OCIE0A);
  TCCR0B |= (1<<CS02) | (1<<CS00); 

  sei();  //enable global ints

  while( 1 ) 
  {

    if( get_key_press( 1 << KEY_RED ) ) {
      t1++;
      if( t1 == 10 )
        t1 = 0;
    }

    if( get_key_press( 1 << KEY_BLUE ) ) {
      t1--;
      if( t1 == 0xFF )
        t1 = 9;
    }

   // PORTB = zahlen[ cnt ];
  }
}

[daniel san (Gast)]

Hi, also hab grad ein volatile vor der deklaration der globalen 
Variablen: uint8_t t1,t2,t3 gesetzt nun funktionierts aber warum??

volatile uint8_t t1,t2,t3;
volatile uint8_t cnt;

Kannst du mir das vielleicht erklären?

[daniel san (Gast)]

Volatile sagt ja den compile das er nicht optimieren soll, aber in 
welchen Zusammenhang hat das hier zu tun?

[Hannes L. (hannes)]

daniel san schrieb:
> in
> welchen Zusammenhang hat das hier zu tun?

Globaler Zugriff auf Variablen...

...

[Karl H. (kbuchegg)]

daniel san schrieb:
> Hi, also hab grad ein volatile vor der deklaration der globalen
> Variablen: uint8_t t1,t2,t3 gesetzt nun funktionierts aber warum??
>
> volatile uint8_t t1,t2,t3;
> volatile uint8_t cnt;
>
> Kannst du mir das vielleicht erklären?

http://www.mikrocontroller.net/articles/FAQ#Was_hat_es_mit_volatile_auf_sich