C Timer programmieren?

[Jawaiica]

Hallo Leute,

ich bin wie ihr seht neu in diesem Forum und komme gleich mit einer Frage zu euch und zwar habe ich den Tag heute genutzt, um mir eine schöne Binäruhr zu bauen und nun fehlt mir noch die Software, die ich morgen programmieren wollte. Leider weiß ich nicht genau, wie ich einen Timer programmieren kann und deshalb meine Frage:
Wie programmiert man solch einen Timer?

Ich habe schon einmal gegooglet und dort mehrere Timer ausprobiert, doch bei einigen kamen nur Fehler und der letzte, der momentan noch auf meinem Atmega8 ist, ist ungenau(habe 5 sekunden programmiert, beim 1. Durchgang noch ok, danach sind es nur noch 4 Sekunden).

Da es sich um eine Uhr handelt, sollte möglichst genau eine Sekunde herauskommen. Den Rest habe ich eigentlich schon fast fertig, mir fehlt lediglich der Timer, damit ich die Sekunden etc. hochzählen kann.


Ich hoffe, dass ihr mir helfen könnt.

MfG Jawaiica

 

[Dirk]

Hallo Jawaiica,

Willkommen im AVR-PRAXiS Forum.

Wenn der Timertakt von dem Quarzoszillator XTAL1/2 abgeleitet wird, sind die Fehlergrenzen für eine Uhr zu groß.

Besser ist es, einen AVR-Mikrocontroller zu verwenden, der einen RTC-Oszillator (TOSC1/2) besitzt. Man kann hier einen Timer mit 32,768kHz asynchron takten, das wird genauer.

Eventuell reicht aber der Takt vom XTAL1/2 Quarz für deine Anwendung. Vielleicht hängst du einfach mal den Code an, den du bisher hast, der für die Initialisierung des Timers zuständig ist, die Timer Interruptserviceroutine am besten auch.

Grüße,
Dirk

 

[Jawaiica]

Also laut dem Datenblatt von dem Atmega8 sollte das gehen:

The clock source for Timer/Counter2 is named clkT2S. clkT2S is by default connected to the main
system I/O clock clkI/O. By setting the AS2 bit in ASSR, Timer/Counter2 is asynchronously
clocked from the TOSC1 pin. This enables use of Timer/Counter2 as a Real Time Counter
(RTC). When AS2 is set, pins TOSC1 and TOSC2 are disconnected from Port B. A crystal can
then be connected between the TOSC1 and TOSC2 pins to serve as an independent clock
source for Timer/Counter2. The Oscillator is optimized for use with a 32.768kHz crystal. Applying
an external clock source to TOSC1 is not recommended.

Aber das wäre doch dann ein externer quarz/oszilator oder nicht? Ich würde es gern mit dem internen versuchen.
Hier mal mein Code:

http://codepad.org/5MgfQsIV

(das ist jetzt der aller letzte [VerzweiflungsAkt] Versuch).


MfG Jawaiica

 

[Dirk]

Hallo,

ich denke das Code-Beispiel ist soweit richtig.

Man erhält einen Compare-Ereignis alle 1s. Voraussetzung ist, dass der Mikrocontroller einen Systemtakt von 1MHz erhält. (CTC Mode, Comparewert: 15624, fclk = 1MHz / 64)

Ich gehe davon aus, dass der interne 1MHz RC-Oszilaltor verwendet wird (Fusebiteinstellung von Werk aus). Für eine Uhr hat der RC-Oszillator zu große Fehlergrenzen.

Fügst du noch weiteren Code innerhalb der while(1) Schleife ein, dann muss dieser in weniger als 1s ausgeführt werden. Ansonsten bekommst du ein oder mehrere Compareereignisse nicht mit, du "verlierst" also Sekunden.

Um das zu verhindern, könntest du Sekunden, Minuten und Stunden innerhalb der TimerCompare-Interruptroutine inkrementieren.

Einen Takt mit kleineren Fehlergrenzen erhältst du, wenn du an die Pins TOSC1/2 einen 32,768kHz Quarz anschließt und den Timer asynchron durch diesen Takt betreibst. Leider liegen beim ATmega8 TOSC- und XTAL-Oszillator auf den selben Pins. Wenn du also TOSC verwendest, musst du für den Systemtakt den internen RC-Oszillator verwenden, was aber nicht unbedingt ein Nachteil ist.

Das untere Programm müsste also fehlerfrei laufen, ich nehme aber an, dass dein tatsächlicher Code anders aussieht. Du hast bestimmt noch weiteren Code innerhalb der while(1) Schleife, der verhindert, dass if(TIFR & (1 << OCF1A)) ausreichend oft abgefragt wird.

Vielleicht hilft dir das schon weiter.

Grüße,
Dirk

int main(void)
{
    DDRB = 0xFF;                            //PORTB = Output
    DDRC = 0xFF;                            //PORTC = Output
    DDRD = 0xFF;                            //PORTD = Output
    
    TCCR1B |= (1 << WGM12);
    OCR1A   = 15624;
    TCCR1B |= ((1 << CS10) | (1 << CS11));    //
  
    while(1)
    {
        if(TIFR & (1 << OCF1A))
        {
            TIFR = (1 << OCF1A);            //Timer reset
            Sekunden++;                        //Sekunden um eins erhöhen
            if(Sekunden >= 60)                //Wenn Sekunden >= 60
            {
                Sekunden = 0;                //Sekunden auf 0 setzen
                Minuten++;                    //Und Minuten erhöhen
                if(Minuten >= 60)            //Wenn Minuten >= 60
                {
                    Minuten = 0;            //Minuten auf 0 setzen
                    Stunden++;                //Stunden erhöhen
                    if(Stunden >= 24)        //Wenn Stunden >= 24
                    {
                        Stunden = 0;        //Stunden auf 0 setzen
                    }
                }
            }
        }
                            
    }
    
    return 0;
}

 

[Jawaiica]

Hmm ok also in meiner While Schleife hatte ich sonst nur meine viele if-Abfragen(weil ich nicht anders weiß, wie ich das sonst machen könnte mit dem zählen^^) und ich kann mir gut vorstellen, dass diese ne Menge Zeit verbrauchen.
Kann man denn berechnen, wie viel Zeit dieses überprüfen benötigt, damit ich das anpassen kann?^^ Wenn nicht muss ich mal gucken wie ich das dann mit dem Uhrenquarz machen kann... wobei ich dann auch nicht genau weiß, wie ich damit die Zeiten berechnen kann.

 

[Dirk]

Hallo,

der aktuelle Code benötigt kaum Zeit (grob 5 bis 20us bei fck 1MHz), ich würde mal sagen, dass der Code soweit fehlerfrei läuft. Allerdings ist es so, dass dein Programm ja noch nicht fertig ist, du möchtest ja mit Sekunden, Minuten und Stunden irgendwas machen. Hier wirst du sicherlich dein Programm innerhalb der while(1) Schleife noch erweitern und das könnte dann zu viel Zeit benötigen, so dass du ein Setzen des Interruptflags des Timers nicht immer mitbekommst, dadurch verlierst du Sekunden, die Uhr geht falsch. Wie hast du es im Moment festgestellt, dass die Uhr nicht richtig läuft, via Simulator, ein Code zur Ausgabe (USART, Display ...) fehlt ja?

Die Sache mit den Fehlergrenzen der Taktquelle für den Timer/Counter1 ist eine andere Baustelle und hat mit der Struktur des Programms erst mal nichts zu tun. Ich würde das mit dem asynchronen Takten des Timer (Uhrenquarz an TOSC1/2) erst mal nach hinten schieben und schauen, dass die Struktur des Programms in Ordnung ist.

Sorry, wenn ich dir nur Tipps geben kann. Ich hoffe, die bringen dich ein bisschen weiter bei deinem Projekt. Vielleicht kann ja sonst noch jemand ein bisschen helfen.

Dirk

 

[Jawaiica]

Ne also Tipps reichen mir auch schon Ich will ja versuchen, soviel wie möglich selbst zu machen^^

Herausgefunden, dass die Uhr falsch läuft habe ich, indem ich auf dem Netbook ne Atomuhr aufgerufen habe und dann verglich, ob alles richtig läuft und nach dem 2. Durchlauf waren es dann noch ca. 4.5 Sekunden statt 5 und nach dem 4. oder 3. Durchgang waren es nur noch 4 Sekunden, da hat es sich dann auch "eingependelt".

Von der Struktur her würde ich jetzt nichts mehr ändern, ich würde halt nur noch so viele If-Abfragen hinzufügen, wie benötigt werden. Das wären dann ja um die 144 >.< (60 für sekunden; 60 für Minuten; 24 für Stunden). Also das dürfte sehr viel Zeit "fressen", weshalb ich mir einen quarz bestellt habe mit der oben genannten Frequenz.

Das Programm würde dann zum Beispiel so aussehen, nur halt mit wesentlich mehr Abfragen:
http://codepad.org/VrpZ1Fju


MfG Jawaiica

 

[Dirk]

Hallo,

Ich will ja versuchen, soviel wie möglich selbst zu machen^^

Das ist eine gute Einstellung

Nochmal ein Tipp zu deinen ganzen if-Abfragen:
Ich weiß nun nicht, welche Daten du an Ports ausgeben möchtest. Vielleicht wäre es sinnvoll, eine bzw. mehrere Tabelle(n) für die Pin-Zustände im Flash-Memory anzulegen. So hättest du nur wenige Instruktionen, um die Portpins richtig zu setzen.

Dirk

Hier mal nur das Prinzip:

#include <avr/pgmspace.h>
// ...
const uint8_t  SekundenTabelleA[] PROGMEM = {0b00000000,  0b00010000 ..... };

//...
while(1)
{
  // ...
  PORTA = pgm_read_byte(&SekundenTabelleA[Sekunden]);
  // ...
}

 

[Jawaiica]

Ich wusste gar nicht, dass das so möglich ist! Ich werde mich nach der Schule gleich mal ransetzen und damit ein wenig rumprobieren(auch wenn es ungenauer wird nur als Test^^).

Mal gucken wann der Quarz kommt.. Viele Dank für die Hilfe! Wenn was ist weiß ich ja, wo ich fragen muss

 

[Jawaiica]

Gut mein Quarz ist gekommen und jetzt weiß ich nicht mehr weiter.. Der Quarz muss ja mit den Pins6 und 7 am PORTB verbunden sein oder? Wenn ja, wie geht es dann weiter?^^ (Ich habe noch nie mit Quarzen gearbeitet deswegen frage ich.. Auf einer Seite wurden dann zwei 22µF Kondensatoren dahinter geschaltet(an beide Verbindungen des Quarzes).

Es ist ein 32.768 kHz Quarz von Conrad (Conrad.de).

Außerdem habe ich noch eine Frage, da mir die Pins ausgehen, wenn ich den anschließe Kann ich die Pins am Atmega8 auch doppelt belegen? Also eine LED und einen Quarz an den Pin anschließen?


MfG Jawaiica

 

[dino03]

Hallo,

Der Quarz muss ja mit den Pins6 und 7 am PORTB verbunden sein oder? Wenn ja, wie geht es dann weiter?^^ (Ich habe noch nie mit Quarzen gearbeitet deswegen frage ich.. Auf einer Seite wurden dann zwei 22µF Kondensatoren dahinter geschaltet(an beide Verbindungen des Quarzes).

PICO-Farad nicht Micro-Farad. Also an jedem Anschluß 22pF und NICHT 22µF
Das ist ein Faktor von eine Million !

Es ist ein 32.768 kHz Quarz von Conrad (Conrad.de).

Ach ... nen Uhrenquarz. Der kommt nicht an XTAL1 und XTAL2 sondern an TOSC1 und 2.
Die Anschlüsse XTAL1+2 sind der Systemoszillator für den Betriebstakt. TOSC1+2 ist ein weiterer zweiter Oszillator der nur für die Timer da ist. Der hat interne Kondensatoren für die Uhrenquarze. Normalerweise also nur den Quarz dran und gut ist.

Außerdem habe ich noch eine Frage, da mir die Pins ausgehen, wenn ich den anschließe Kann ich die Pins am Atmega8 auch doppelt belegen? Also eine LED und einen Quarz an den Pin anschließen?

Nein! Definitiv nicht. Du kannst ne Lampe ja auch nicht gleichzeitig mit 12V und 230V betreiben Also die Pins wo der Oszillator, Betriebsspannung, Reset, ... dran ist kannst du nicht doppelt belegen. Bei den anderen Pins geht das nur über etliche Klimmzüge und wenn man wirklich weiß was man da tut. Darum ist es am Anfang am wichtigsten das man genau plant was man alles braucht und wie man es am besten auf die vorhandenen Pins verteilt. Als Anfänger sollte man Pins nicht für zwei Funktionen gleichzeitig verwenden. Das geht ziemlich sicher in die Hose weil meißt noch nicht bekannt ist wie es tief im inneren des Controllers abläuft.

Gruß
Dino

 

[Jawaiica]

Ach doch pF? ja ok dann hab ich mich ein "wenig" verlesen na gut dann muss ich mal eben gucken wie ich das dann mit den Sekunden regeln werde.

Zum Thema einfach anschließen: Muss ich dann nicht auch iwie dem Chip via Programm sagen, dass er DEN Quarz als Timer verwenden soll?^^


MfG Jawaiica

 

[Dirk]

Hallo,

nicht jeder Uhrenquarz funktioniert mit dem TOSC-Oszillator. In der Regel verwendet man für diesen Oszillator keine externe Kondensatoren.

Bei dem Atmega8 kannst du den Timer2 asynchron durch den TOSC-Oszillator takten.

Ich stelle hier mal einen Codeausschnitt ein, den wir in abgewandelter Form für die Endkontrolle des Mega2560-USB Mikrocontrollermoduls verwenden.

Ich hoffe, ich habe die Registernamen und Bitnamen des ATmega8 einigermaßen getroffen

Der Code macht folgendes:
Die CompareInterruptRoutine des Timer2 toggelt PB0. In main() wird die Taktquelle des Timer2 auf asynchronen Takt von TOSC-Oszillator gestellt.
Timer/Counter und OutputCompareRegister werden initialisiert. Der Timer wird auf CTC Mode (Clear Timer on Compare) eingestellt, Prescaler auf 128.
Der OutputCompare-Interrupt wird freigegeben, Interrupts werden global freigegeben.

Für die Berechnung des Comparewertes ist eventuell unser Tool AVR-Timer-Calculator hilfreich.

Vielleicht hilft dir der Code ja weiter.

Gruß,
Dirk

ISR(TIMER2_COMP_vect)
{
  // Eventtime = 500ms
  if (PORTB & (1<<PB0))
  {
    PORTB &= ~(1<<PB0);
  } else {
    PORTB |= (1<<PB0);
  }
}


int main (void)
{

  uint8_t i

  DDRB |= (1<<PB0);     // OUTPUT

  _delay_ms(200);

  ASSR = (1<<EXCLK) | (1<<AS2);     // TOSC1/2 für Timer2, Externer Clock
  TCNT2 = 0;
  OCR2 = 127;                      // Eventtime = 500ms
  TCCR2 = (1<<WGM21) | (1<<CS22) | (1<<CS20);   // CTC-Mode (WGM2..0 = 010), prescaler 128
  TIMSK = (1<<OCIE2);
  TIFR = (1<<OCF2);

  while ((ASSR & ((1<<TCN2UB) | (1<<OCR2UB) | (1<<TCR2UB))) != 0) { };

  sei();

  while (1)
  {

  }

  return 0;
}

 

[Jawaiica]

Ok, also irgendwie "überfordert" mich der Code ein wenig

ISR(TIMER2_COMP_vect) { ... }

Da muss ich doch dann die "Zeitkritischen" Sachen drin haben richtig? Sprich das Sekunden hochzählen etc.?

ASSR = (1<<EXCLK) | (1<<AS2);

Hier kriege ich bei (1<<EXCLK) nen Fehler(Undeclared).
Beim letzten Code war es ja so, dass man per If-Abfrage dann immer die Zeit erhöht hat:

if(TIFR & (1 << OCF1A))

Wie müsste ich das denn bei dem Code da machen?^^ Die Zeit wird ja immer nur um 500ms erhöht so wie ich das sehe. Das Togglen vom Port ist das wichtig?
Also wie Du siehst versteh ich da eigentlich recht wenig >.<

 

[Dirk]

Die ISR benötigst du nicht unbedingt, du kannst auch weiterhin das Interrupt-Flag in dem Hauptprogramm abfragen.

Du verwendest aktuell Timer 1, du musst aber nun den Timer2 (8Bit Timer) verwenden, da sich nur dieser asynchron takten läßt.

Die Abfrage sieht dann so aus:

while (1)
{

  if(TIFR & (1 << OCF2))  // Flag gesetzt?
  {   
    TIFR = (1 << OCF2);    // Flag manuell wieder löschen

    // ...

Im Register ASSR git es kein Bit EXCLK, das entfernst du aus der Zeile (es wird beim ATmega2560 benötigt, ich hatte es vergessen zu entfernen, ich habe auch das Datenblatt des Mega8 nicht im Kopf )

Den Portpin PB0 toggeln musst du natürlich nicht, es ist nur als Beispiel zu sehen.

Bei einem Prescaler von 128 ergibt sich für das Compare-Register ein Wert von 255. Siehe unten.

Der Wert passt gerade noch in das 8Bit-Register. Du kannst aber auch die anderen Kombinationen verwenden,
der Mikrocontroller muss nur die entsprechenden Prescaler unterstützen (-> Datenblatt).

Es würde auch gehen: Prescaler=256 und Compare=127


Dirk

 

[Jawaiica]

Vielen Dank!
Ein "kleines" Problem bleibt bei mir aber immer noch^^ Ich weiß nicht wie man den Prescaler ändert Gibt es irgendwie einen Trick um den richtig abzulesen? Ich muss nämlich ein wenig rumprobieren, da die Zeit noch zu schnell verläuft

MfG Jawaiica

 

[Dirk]

Hallo,

Ein "kleines" Problem bleibt bei mir aber immer noch^^ Ich weiß nicht wie man den Prescaler ändert Gibt es irgendwie einen Trick um den richtig abzulesen?

du müsstest hier in das Datenblatt schauen (das findest du auch bei uns in der AVR-PRAXiS Database). Dort schaust du in das Kapitel

8Bit Timer/Counter2
- 8Bit Timer/Counter Register Description

Dort gibt es eine Tabelle mit den Prescalerbits (Clock Select Bits). Diese befinden sich bei dem ATmega8 im Control-Register TCCR2.

Wenn du ein Prescalerbit setzt, läuft der Timer.


Dirk

 

[Jawaiica]

Hmm, also irgendwie habe ich das Gefühl, dass da was nicht stimmt.
Mit dem AVR Timer calculator kann man ja die Werte berechnen die man eingeben muss, damit genau eine Sekunden um geht oder? Ich hab es jetzt mit allen Werten versucht die ich raus bekommen habe und ich habe nie genau eine Sekunde.
Ich habe mal "gemessen(abgeschaut^^)" wie lange ich für eine Minute mit der Uhr brauche und das sind um die 11 Sekunden.
Habe ich jetzt irgendwas falsch gemacht oder woran kann das liegen?


MfG Jawaiica

 

[Dirk]

Kannst du mal deinen kompletten Soucecode anhängen, vielleicht sehe ich dann einen Fehler.
So kann ich jetzt schlecht was sagen. Ich denke mal, dass die Initialisierung soweit richtig ist,
hundertprozentig bin ich mir allerdings nicht sicher, ich kann es auch im Moment selber
nicht testen.

Dirk

 

[Jawaiica]

Also "mein" Code sieht dann so aus:
http://codepad.org/Lghj8rjR

(sry weiß nicht wieso aber bei mir ist der Code immer verrutscht wenn ich ihn hier posten will^^)

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
																//00																													   10																														20																														30																														40																														50																														60
																//-|------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|----|
const uint8_t	WerteTabelleMinutenUndStunden[]		PROGMEM = {0b00000000, 0b00000001, 0b00000010, 0b00000011, 0b00000100, 0b00000101, 0b00000110, 0b00000111, 0b00001000, 0b00001001, 0b00010000, 0b00010001, 0b00010010, 0b00010011, 0b00010100, 0b00010101, 0b00010110, 0b00010111, 0b00011000, 0b00011001, 0b00100000, 0b00100001, 0b00100010, 0b00100011, 0b00100100, 0b00100101, 0b00100110, 0b00100111, 0b00101000, 0b00101001, 0b00110000, 0b00110001, 0b00110010, 0b00110011, 0b00110100, 0b00110101, 0b00110110, 0b00110111, 0b00111000, 0b00111001, 0b01000000, 0b01000001, 0b01000010, 0b01000011, 0b01000100, 0b01000101, 0b01000110, 0b01000111, 0b01001000, 0b01001001, 0b01010000, 0b01010001, 0b01010010, 0b01010011, 0b01010100, 0b01010101, 0b01010110, 0b01010111, 0b01011000, 0b01011001, 0b01100000};
const uint8_t	WerteTabelleSekunden[]				PROGMEM	= {0b00000000, 0b00000001, 0b00000010, 0b00000011, 0b00000100, 0b00000101, 0b00000110, 0b00000111, 0b00001000, 0b00001001, 0b00010000, 0b00010001, 0b00010010, 0b00010011, 0b00010100, 0b00010101, 0b00010110, 0b00010111, 0b00011000, 0b00011001, 0b00100000, 0b00100001, 0b00100010, 0b00100011, 0b00100100, 0b00100101, 0b00100110, 0b00100111, 0b00101000, 0b00101001, 0b00110000, 0b00110001, 0b00110010, 0b00110011, 0b00110100, 0b00110101, 0b00110110, 0b00110111, 0b00111000, 0b00111001, 0b00000000, 0b00000001, 0b00000010, 0b00000011, 0b00000100, 0b00000101, 0b00000110, 0b00000111, 0b00001000, 0b00001001, 0b00010000, 0b00010001, 0b00010010, 0b00010011, 0b00010100, 0b00010101, 0b00010110, 0b00010111, 0b00011000, 0b00011001, 0b00100000};

volatile unsigned int Sekunden = 0;
volatile unsigned int Minuten  = 0;
volatile unsigned int Stunden  = 0;

int main(void)
{
	DDRB = 0xFF;							//PORTB = Output
	DDRC = 0xFF;							//PORTC = Output
	DDRD = 0xFF;							//PORTD = Output
	
	ASSR = (1<<AS2);						// Externe Uhr
	TCNT2 = 0;
	OCR2 = 255;								// Compare
	TCCR2 = (1<<WGM21) | (1<<CS22) | (1<<CS20);   // prescaler 128
	TIMSK = (1<<OCIE2);
	TIFR = (1<<OCF2);
  
    while(1)
    {
		if(TIFR & (1 << OCF2))
		{
			TIFR = (1 << OCF2);				//Timer reset
			Sekunden++;						//Sekunden um eins erhöhen
			if(Sekunden >= 60)				//Wenn Sekunden >= 60
			{
				Sekunden = 0;				//Sekunden auf 0 setzen
				Minuten++;					//Und Minuten erhöhen
				if(Minuten >= 60)			//Wenn Minuten >= 60
				{
					Minuten = 0;			//Minuten auf 0 setzen
					Stunden++;				//Stunden erhöhen
					if(Stunden >= 24)		//Wenn Stunden >= 24
					{
						Stunden = 0;		//Stunden auf 0 setzen
					}
				}
			}
		}
		PORTC = pgm_read_byte(&WerteTabelleSekunden[Sekunden]);
		PORTD = pgm_read_byte(&WerteTabelleMinutenUndStunden[Minuten]);
		PORTB = pgm_read_byte(&WerteTabelleMinutenUndStunden[Stunden]);
		if(Sekunden >= 40)
		{
			PORTD = (1<<PD7);
		}
		else
		{
			PORTD &= ~(1<<PD7);
		}						
    }
	
	return 0;
}

Aber ich glaube ich muss jetzt sowieso erst einmal warten und nen neuen Chip bestellenmuss, da meiner nicht mehr erkannt wird, nachdem ich in AVR Studio 5 mit den fuses gespielt habe
Da kommt jetzt immer, dass er nicht mit dem Programmer connecten kann...


MfG Jawaiica