Mit AtMega16 und Timern LEDs blinken lassen

[CSG (Gast)]

Hallo,

ich habe mir gerade einige Anleitungen zur Programmierung mit Timern 
angeschaut, habe jedoch noch einige Fragen bzgl. den Interrupts, die von 
den Timern ausgelöst werden.

Wie eingangs im Betreff erwähnt möchte ich zum Test eine LED (PD5) im 
Timer-Intervall des Timers 0 blinken lassen. Um etwas zu sehen, wollte 
ich das Prescaling auf Takt/1024 stellen, also setze ich im Register 
TCCR0 folgende Bits:
CS00: 1
CS01: 0
CS02: 1

Der Interrupt soll ausgelöst werden, wenn ein Overflow der 
Timer-Variable vorliegt. Welche Bits müssen hierfür noch gesetzt werden 
und wie fange ich diesen Interrupt dann ab? Habe zwar einige Tutorials 
gefunden, allerdings waren die alle für Assembler und das kann ich nicht 
wirklich.

Ich programmiere mit AVR-GCC unter Linux.

Vielen Dank!

[Karl H. (kbuchegg)]

> Habe zwar einige Tutorials
> gefunden, allerdings waren die alle für Assembler und das kann
> ich nicht wirklich.

Auch in Assembler werden dieselben Register mit denselben Werten belegt.

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

// Timer/Counter0 Overflow
//
ISR( TIMER0_OVF_vect )
{
  // ... mach was
} 

int main(void)
{

  //
  // Konfiguration Timer0
  //
  TCCR0 |= (1 << CS00) | (1 << CS02);
  TIMSK |= (1 << TOIE0);                // Overflow Interrupt

  sei();

  while(1)
  {
  }
}

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

[oldmax (Gast)]

Hi
Was ist an Assembler so schwer ? Es ist die einfachste Art, ein Programm 
zu coden und zu wissen, was sich auf dem Chip tut. Wer C beherscht, weiß 
noch lange nicht, wie oft ein Wert in den Registern manipuliert wird. 
Erkann nicht so einfach sagen, dieser Programmabschnitt wird in 31 µSek 
durchlaufen. Aber das braucht er vermutlich auch nicht. Andererseits, 
grad bei Bitbearbeitung ist's nicht verkehrt, wenn die Manipulation der 
Werte im Programm "sichtbar" ist. Und umfangreiche Programme lassen sich 
in C genauso unübersichtlich  wie sich Assemblerprogramme mit den 
richtigen Methoden übersichtlich gestalten lassen können. Von daher ist 
es kein Grund, Assemblerroutinen von vorn herein abzulehnen. Ich glaube 
eher, das liegt nicht an der Programmiersprache, sondern daran, das ein 
Anderer seine Gedanken zu einem Programm geformt hat. Und wenn eines 
schwierig ist, ist es Programme anderer zu analysieren. Geht mir mit C, 
Basic, Pascal und Assembler und diversen anderen Steuerungs-Programmen 
genauso. Nur meine eigenen Versuche sind völlig logisch und klar.... 
(Ironie aus) Übrigends sehen es meine Kollegen genauso.
Versuch doch mal, die in den Tutorialsbesschriebenen Programme 
abzuarbeiten. Soviel Code ist's ja nicht und man kann sehr leicht 
nachvollziehen, was da geschieht. Hast du die Timer verstanden, ist's 
mit dem Blinken kein Problem mehr. Dafür ist eine XOr Verknüpfung 
bestens geeignet. Ich habe mir in meine Programme ein Blink-Maske 
gebaut.

LDS R10, Blink_Mask ; Register 10 mit Variable laden
LDI R11, 0b11111111 ; Register 11 mit logischen 1sen belegen 
(nicht wegen dem Format meckern, ich weiß, das es auch anders geht)
EOR R10, R11        ; XOr mit 1 ergibt in Variable andere Bitlage
STS Blink_Mask, R10 ; Variable zurückschreiben
LDS R11, Ausgabe    ; Ausgabewert holen
AND R11, R10        ; Und BlinkMaske
STS Ausgabe         ; und zurückschreiben, Ausgabe erfolgt in eigener UP

Damit erhälst du eine Blinkende Ausgabe, wenn du diese Zeilen in 
bestimmten Zeitintervallen aufrufst.
Gruß oldmax