Entprellroutine von Peter in Code einfügen, aber wie?

[Mathias O. (m-obi)]

Hallo,

ich möchte gerne die Entprellroutine von Peter D. verwenden. Aber wie 
füge ich die bei mir ein. Kann man mehrere ISR in einem Code verwenden, 
weil ich hab schon eine und in der Entprellroutine ist ja auch eine?

// ATmega16 @ 16MHz

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

#define Taster_1 (PIND&(1<<PD2))
#define Taster_2 (PIND&(1<<PD3))
#define Taster_3 (PIND&(1<<PD4))

uint8_t var1 = 0;
uint8_t var2 = 0;

ISR(TIMER0_OVF_vect)
{  
  PORTA = 0xff;
}


int main(void)
{
    
  DDRA = 0b11111111;
  DDRB = 0b11111111;
  DDRC = 0b11111111;
  DDRD = 0b11100011;
  
  TCCR0 |= (1<<CS02);      // Prescaler: 256
  //TCCR0 |= (1<<CS00)|(1<<CS02);  // Prescaler: 1024
  TIMSK |= (1<<TOIE0);
  
  sei();

  while(1)
  {     
    if (Taster_1 && TCNT0 == 255)
    {
    var2++;
    if (var2 == 50)
    {
      var1++;
      var2 = 0;
    }
    }
    
    if (TCNT0 == var1) 
    {
      PORTA = 0x00;
    }
      
    }
}

[Karl H. (kbuchegg)]

Mathias O. wrote:
> Hallo,
>
> ich möchte gerne die Entprellroutine von Peter D. verwenden. Aber wie
> füge ich die bei mir ein. Kann man mehrere ISR in einem Code verwenden,
> weil ich hab schon eine und in der Entprellroutine ist ja auch eine?

Du musst 2 Fälle unterscheiden:

* wenn deine Timereinstellung (Vorteiler) gravierend von der der 
Entprellerei abweicht, dann muss eines der beiden Subsysteme auf einen 
anderen Timer ausweichen. Das ist aber nur notwendig, wenn die 
Overflowzeiten gravierend voneinander abweichen.

* Wenn die Einstellungen so halbwegs zusammenpassen, und das tun sie 
eigentlich meistens bis oft, dann führst du ganz einfach die Inhalte 
deiner ISR und der 'Entprell'-ISR zusammen. Unter Umständen musst du die 
Berechnung des Preload anpassen. Ob die ISR alle 10ms oder alle 8 oder 5 
oder 15 aufgerufen wird, ist für die Entprellung relativ egal.

ISR(TIMER0_OVF_vect)
{
  //
  // der Teil, der für die Entprellung zuständig ist
  //
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
 
  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;
  }

  //
  // und was sonst noch in dieser ISR zu geschehen hat
  //
   PORTA = 0xff;
}

[Mathias O. (m-obi)]

Anderer Timer heißt dann Timer1?

[Micha (Gast)]

>Anderer Timer heißt dann Timer1?
Oder Timer 2, oder ...
In welchem Intervall wird denn deine

ISR(TIMER0_OVF_vect)

aufgerufen?

[Karl H. (kbuchegg)]

Micha wrote:
>>Anderer Timer heißt dann Timer1?
> Oder Timer 2, oder ...
> In welchem Intervall wird denn deine
>

ISR(TIMER0_OVF_vect)

> aufgerufen?

Du bist gemein :-)
Wäre ja auch zu einfach, diese Zeit einfach mal auszurechnen.

[Mathias O. (m-obi)]

Wenn ich jetzt genau gerechnet habe, mit 16 MHz und einen Prescaler von 
256, habe ich 4080µs pro Intervall von 0 bis 255.

[Karl H. (kbuchegg)]

Gut. Auf diesen Zahlenwert bin ich auch gekommen.
4080 µs sind knapp 4ms. Was sagt dir das zum Thema Entprellung?

Hinweis: Schmeiss den Timer Reload auf 10ms in der ISR raus und alles 
ist gut.

[Mathias O. (m-obi)]

Du meinst also ich soll dies

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

rausnehmen und den Rest einfach übernehmen?

Kann mir denn jemand auchmal erklären was der Code macht? Ich hab ja mal 
gelernt, Punktrechnung geht vor Strichrechnung...

[Micha (Gast)]

>Du bist gemein :-)
Nö. Nur zu faul... ;-)

[Micha (Gast)]

>Du meinst also ich soll dies
>TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
>rausnehmen und den Rest einfach übernehmen?
Jep.

>Kann mir denn jemand auchmal erklären was der Code macht?
Das wird in dem Thread, aus dem du den Code hast (weiter unten) erklärt.

[Karl H. (kbuchegg)]

Mathias O. wrote:

> Kann mir denn jemand auchmal erklären was der Code macht? Ich hab ja mal
> gelernt, Punktrechnung geht vor Strichrechnung...

Ja.
Genau das macht er. Punkt vor Strich rechnen.
Schmeis den Taschenrechner an, setz deine Zahlenwerte ein und sieh nach 
was rauskommt. Dann überleg dir was es wohl für den nächsten Überlauf 
des Timers zeitmässig bedeuten könnte, wenn man diesen Wert in das 
Timerregister lädt und den Timer von dort wegzählen lässt.
Hinweis: Du brauchst dazu das wissen wie lange es dauert, bis der Timer 
um 1 weitergezählt hat. Und du brauchst das Wissen, das für den Timer -1 
dasselbe ist wie 254, -2 dasselbe wie 253, -3 dasselbe wie 252 etc.