Vorteiler berechnen

[Delay (Gast)]

Wenn der Timer0 mit einer Zeitverzögerung von 1ms realisiert werden 
soll...
und der CPU-Takt 8MHz beträgt...

Wie komme ich dann darauf, dass ich für das TTCR0 den Vorteiler 64 
nehme?

[Düsendieb (Gast)]

(1/8.000.000)*64 = 8µsec : das währe die Zeit die die Interruptroutine 
aufgerufen werden würde, wenn in Timerregister 255 steht.

8µs * 255 = 2,04ms : das währe die Zeit die die Interruptroutine 
aufgerufen werden würde, wenn in Timerregister 0 steht.

Da die 1ms in zwischen diesen Werten liegt ist der Vorteiler OK.

Axel

[Purzel H. (hacky)]

Ein relativ triviales Vorgehen ist das Scope anzuhaengen und die 
moeglichen Werte durchzuprobieren.

[Karl H. (kbuchegg)]

Delay schrieb:

> Wie komme ich dann darauf, dass ich für das TTCR0 den Vorteiler 64
> nehme?

Durch rechnen?
So viele Vorteiler gibts ja nicht. Also rechnet man sich mit allen 
verfügbaren Vorteilern aus, welche Interruptfrequenz da rauskommt.

[david (Gast)]

Für Rechenfaule: http://www.avrcalc.com/

Gruss
david

[Delay (Gast)]

Karl Heinz Buchegger schrieb:
> Delay schrieb:
>
>
> Durch rechnen?
> So viele Vorteiler gibts ja nicht. Also rechnet man sich mit allen
> verfügbaren Vorteilern aus, welche Interruptfrequenz da rauskommt.

Mir war/ist nicht ganz bewusst wie ich durch rechnen darauf komme.

[Karl H. (kbuchegg)]

Delay schrieb:
> Karl Heinz Buchegger schrieb:
>> Delay schrieb:
>>
>>
>> Durch rechnen?
>> So viele Vorteiler gibts ja nicht. Also rechnet man sich mit allen
>> verfügbaren Vorteilern aus, welche Interruptfrequenz da rauskommt.
>
> Mir war/ist nicht ganz bewusst wie ich durch rechnen darauf komme.

FAQ ganz unten

[Uwe (de0508)]

Hallo !

ich lasse das immer der Preprocessor von avr gcc erledigen.

#define T0_FREQUENCE    1000UL      // 1000Hz

// --------------------------------------------------------
// Timer0 ist 8 Bit
// Wir berechnen den optimalen Prescale-Faktor
// --------------------------------------------------------

#define T0_MAX_COUNTER    256UL

// --------------------------------------------------------
// 8-Bit Timer - Timer0
// --------------------------------------------------------
#define _T0_PRESCALE_0    (0)
#define _T0_PRESCALE_1    (1<<CS00)
#define _T0_PRESCALE_8    (1<<CS01)
#define _T0_PRESCALE_64    (1<<CS01 | 1<<CS00)
#define _T0_PRESCALE_256  (1<<CS02)
#define _T0_PRESCALE_1024  (1<<CS02 | 1<<CS00)


// --------------------------------------------------------
// Timer0 Vorteiler berechnen
// --------------------------------------------------------
#if (F_CPU  / T0_FREQUENCE) < T0_MAX_COUNTER
# define T0_PRESCALE    1U      // prescaler :1
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1

#elif (F_CPU  / (T0_FREQUENCE * 8 )) < T0_MAX_COUNTER
# define T0_PRESCALE    8U      // prescaler :8
# define T0_PRESCALE_VALUE  _T0_PRESCALE_8

#elif (F_CPU  / (T0_FREQUENCE * 64 )) < T0_MAX_COUNTER
# define T0_PRESCALE    64U      // prescaler :64
# define T0_PRESCALE_VALUE  _T0_PRESCALE_64

#elif (F_CPU  / (T0_FREQUENCE * 256UL )) < T0_MAX_COUNTER
# define T0_PRESCALE    256U      // prescaler :256
# define T0_PRESCALE_VALUE  _T0_PRESCALE_256

#elif (F_CPU  / (T0_FREQUENCE * 1024UL)) < T0_MAX_COUNTER
# define T0_PRESCALE    1024U      // prescaler :1024
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1024

#else
# error "T0_FREQUENCE"
#endif

// --------------------------------------------------------
// Timer0 Counterwert berechnen um auf T0_FREQUENCE zu kommen
// --------------------------------------------------------

#define T0_COUNTER  (uint16_t)(1.0 * F_CPU / (T0_PRESCALE * T0_FREQUENCE) +0.5)

// in T0_PRESCALE_VALUE stehen dann Bit-Werte für den Prescaler.

[Jörg E. (jackfritt)]

Sorry wenn ich das alte Ding nochmal anpacke,
aber bei mir funktioniert das nur wenn man

define T0_PRESCALE    8UL

setzt.
Hier mal der komplette geänderte Teil

#if (F_CPU  / T0_FREQUENCE) < T0_MAX_COUNTER
# define T0_PRESCALE    1UL      // prescaler :1
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1

#elif (F_CPU  / (T0_FREQUENCE * 8 )) < T0_MAX_COUNTER
# define T0_PRESCALE    8UL      // prescaler :8
# define T0_PRESCALE_VALUE  _T0_PRESCALE_8

#elif (F_CPU  / (T0_FREQUENCE * 64 )) < T0_MAX_COUNTER
# define T0_PRESCALE    64UL      // prescaler :64
# define T0_PRESCALE_VALUE  _T0_PRESCALE_64

#elif (F_CPU  / (T0_FREQUENCE * 256UL )) < T0_MAX_COUNTER
# define T0_PRESCALE    256UL      // prescaler :256
# define T0_PRESCALE_VALUE  _T0_PRESCALE_256

#elif (F_CPU  / (T0_FREQUENCE * 1024UL)) < T0_MAX_COUNTER
# define T0_PRESCALE    1024UL      // prescaler :1024
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1024

#else
# error "T0_FREQUENCE"
#endif

Sons kommt beim berechnen von T0_COUNTER ein falscher Wert raus.


Gruss,

Jörg