Timer und Interrupts beim ATmega 128

OP #2440148
Lesenswert?

Hallo,

ich möchte folgendes machen:


main:
1
//Interrupt-Test
2

3

4

5
   //Set up the timer1 as described in the
6
   //tutorial
7

8
   TCCR1B=(1<<WGM12)|(1<<CS11)|(1<<CS10);
9
   OCR1A=65535;
10
   
11
   OCR1B=35500; // timer2
12
   
13
   
14
   //Enable the Output Compare A interrupt
15
   TIMSK|=(1<<OCIE1A);
16
   
17
   //Enable the Output Compare B interrupt
18
   TIMSK|=(1<<OCIE1B); 
19
   
20
   //Enable interrupts globally
21
   sei();
22

23

24
 while( 1 )
25
 {
26
  
27
 }
28
 
29

30
 
31
 // Ende-Test

Interrupt.c:
1
//The output compate interrupt handler
2
//We set up the timer in such a way that
3
//this ISR is called exactly at 1ms interval
4

5
ISR(TIMER1_COMPA_vect)
6
{
7
    sendchar('I');
8
  sendchar('N');
9
  sendchar('T');
10
  sendchar('E');
11
  sendchar('R');
12
  sendchar('R');
13
  sendchar('U');
14
  sendchar('P');
15
  sendchar('T');
16
  sendchar('A');
17
  
18
  sendchar(13);
19
  sendchar(10);
20
  sendchar(10);
21
  
22
}
23

24
ISR(TIMER1_COMPB_vect)
25
{
26
    sendchar('I');
27
  sendchar('N');
28
  sendchar('T');
29
  sendchar('E');
30
  sendchar('R');
31
  sendchar('R');
32
  sendchar('U');
33
  sendchar('P');
34
  sendchar('T');
35
  sendchar('B');
36
  
37
  sendchar(13);
38
  sendchar(10);
39
  sendchar(10);
40
  
41
}


jedoch erhalte ich als Ausgabe nur gleichmäßig abwechselnd Interrupt A 
und Interrupt B und nicht ungleichmäßig wie gewünscht... Warum???

http://extremeelectronics.co.in/avr-tutorials/timers-in-compare-mode-part-ii/

Quelle...
#2440198
Lesenswert?

J. R. schrieb:
> Okay.... Und wie lässt sich das ändern?

Indem du nur 1 Compare benutzt und im Compare ausrechnest wann und 
welche Aktion als nächstes drann ist.


Wie machst du das denn im täglichen Leben, wenn du nur 1 Uhr mit 
Sekundenzeiger hast, aber mehrere Aktionen in Unterschiedlichen 
Intervallen ausführen sollst? Da hast du doch genau das gleiche Problem 
und löst es unbesehen mit Bravour.
OP #2440241
Lesenswert?

Karl Heinz Buchegger schrieb:
> J. R. schrieb:
>> Okay.... Und wie lässt sich das ändern?
>
> Indem du nur 1 Compare benutzt und im Compare ausrechnest wann und
> welche Aktion als nächstes drann ist.
>
>
> Wie machst du das denn im täglichen Leben, wenn du nur 1 Uhr mit
> Sekundenzeiger hast, aber mehrere Aktionen in Unterschiedlichen
> Intervallen ausführen sollst? Da hast du doch genau das gleiche Problem
> und löst es unbesehen mit Bravour.

Und anders geht das nicht??? :(
#2440263
Lesenswert?

Da du nur 2 Interrupts brauchst, kannst du dir natürlich auch in jeder 
ISR ausrechnen, wann der nächste fällig ist.

Wenn du alle 12 Sekunden eine Aktion machen sollst, aber nur eine Uhr 
hast, kannst du dir ja ausrechnen, wann der eingebaute Wecker für A das 
jeweils nächste mal läuten soll.

Läutet der Wecker das erste mal, stellst du ihn auf 24 Sekunden ein. 
Beim nächsten Läuten stellst du ihn auf 36, dann auf 48, etc. etc.
#2440274
Lesenswert?

Wsa musst du da lang schauen?
1
   TCCR1B = (1<<CS11)|(1<<CS10);
2

3
   OCR1A = 65535;
4
   OCR1B = 35500;
5

6

7
....
8

9
ISR(TIMER1_COMPA_vect)
10
{
11
  send( "A\r\n" );
12
  OCR1A += 65535
13
}
14

15
ISR(TIMER1_COMPB_vect)
16
{
17
  send( "B\r\n" );
18
  OCR1B += 35500;
19
}


(und schreib dir eine Funktion, die Strings versenden kann. Das ist doch 
Unsinn, da jedesmal mit sendchar rumzuhampeln
1
void send( const char* str )
2
{
3
  while( *str )
4
    sendchar( *str++ );
5
}
OP #2440317
Lesenswert?

Karl Heinz Buchegger schrieb:
> (und schreib dir eine Funktion, die Strings versenden kann. Das ist doch
> Unsinn, da jedesmal mit sendchar rumzuhampelnvoid send( const char* str )
> {
>   while( *str )
>     sendchar( *str++ );
> }

Hatte da weng Probleme mit dem \n \r am Ende... da hat er nur immer eins 
erkannt...  keine Ahnung warum....

Aber deine Lsg werde ich moin mal ausprobieren..danke ;)

Für heute ist erst einmal Feierabend angesagt... :)
OP #2441147
Lesenswert?

1
void send(char *send)
2
{
3
  char transmit = 0;
4
  int i = 0;
5

6
  while( !(UCSR1A & (1<<UDRE1)) );
7
  UDR1 = 13;
8

9
  while( (transmit != 10) && (transmit != 13) )
10
  {
11
    transmit = send[i];
12
    i++;
13
    while( !(UCSR1A & (1<<UDRE1)) );
14
    UDR1 = transmit;
15
  }
16

17
  return;
18

19
}

So schaut die bei mir aus... warum geht das dann damit nicht???
#2441152
Lesenswert?

Was um Himmels Willen treibst du da?

Eine String-Sendefunktion soll den String senden, mehr nicht. Auf keinen 
Fall soll sie irgendwelche Annahmen über \r oder \n Zusammenhänge 
treffen oder das der String damit aufhört. Auch kann sich eine String 
Sende Funktion auf eine einfachere Funktion stützen, die ein einzelnes 
Zeichen versendet und die hast du doch schon

Eine Funktion die einen String versendet sieht so aus
1
void send( const char* str )
2
{
3
  while( *str != '\0' )
4
    sendchar( *str++ );
5
}

fertig. Mehr braucht es nicht.
#2441156
Lesenswert?

> warum geht das dann damit nicht???

Weil du eines von beiden, entweder den \n (10) oder den \r (13) gar 
nicht verschickst, sondern immer nur den ersten der beiden. Je nachdem 
wer im String zuerst kommt.

Aber nochmal: Das geht eine String Funktion nichts an, was ich versenden 
will. Und wenn ich

   send( "\r\n\n\r\n\r\n\r Hallo \n\r\n\r" );

aufrufe, dann will ich auch, dass dieser String genau so versendet wird, 
wie ich ihn hingeschrieben habe und nicht, dass die Sendefunktion beim 
ersten \r bereits aufhört. Das ist nicht ihr Bier sich darum zu kümmern!

Ein C-String hört immer beim 0-Character auf. Das ist alles was eine 
Send-String Funktion (so wie jede andere String-verarbeitende Funktion) 
wissen muss.
#2441170
Lesenswert?

J. R. schrieb:
> Karl Heinz Buchegger schrieb:
>> Ein C-String hört immer beim 0-Character auf. Das ist alles was eine
>> Send-String Funktion (so wie jede andere String-verarbeitende Funktion)
>> wissen muss.
>
> Das ist gut... das muss ich mir merken ;-)

Ähm.
Das ist Grundlagen - C Programmierung - Strings.
In jedem C Buch irgendwo im ersten Drittel des Buches in einem eigenen 
Kapitel über Strings lang und breit und 25 Variationen ausgewälzt.

String-Verarbeitung in C
OP #2441175
Lesenswert?

Karl Heinz Buchegger schrieb:
> J. R. schrieb:
>> Karl Heinz Buchegger schrieb:
>>> Ein C-String hört immer beim 0-Character auf. Das ist alles was eine
>>> Send-String Funktion (so wie jede andere String-verarbeitende Funktion)
>>> wissen muss.
>>
>> Das ist gut... das muss ich mir merken ;-)
>
> Ähm.
> Das ist Grundlagen - C Programmierung - Strings.
> In jedem C Buch irgendwo im ersten Drittel des Buches in einem eigenen
> Kapitel über Strings lang und breit und 25 Variationen ausgewälzt.
>
> String-Verarbeitung in C

Ja stimmt eigentlich... Schande über mich ;) Wobei der obige Code nicht 
von mir stammt :-) Ist von einem Kollegen...

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren