Timer1 ISRs Genauigkeit

[sternst]

Bin für Kritik natürlich offen.

Ok, dann lege ich mal los.

* Warum ist i ein uint32_t? uint8_t würde reichen.

* Warum das uint32_t bei prescale[]? uint16_t würde reichen.
(wenn du das änderst, muss aber auch die Zeile der nenner-Berechnung geändert werden)

* Warum ist prescale[] eine automatic- und keine static-Variable?

* Wozu soll die Funktion round() da gut sein? "16000000/nenner" ist eine Integer-Division und hat immer ein ganzzahliges Ergebnis. Da gibt es für round() rein gar nichts zu runden.

All diese Punkte produzieren keinen Fehler, drücken aber auf die Performance. Was allerdings ein Fehler ist, ist dass du bei der OCR-Berechnung für den CTC-Modus ein "-1" vergisst.

Noch was: Du scheinst 0 für "Erfolg" und 1 für "Fehler" zu verwenden. Das finde ich etwas ungeschickt, weil es genau entgegen der boolschen Logik ist (0 = False, 1 = True). Ich würde auch nicht den Prescaler-Wert speichern, sondern den Index, denn den kann man im restlichen Code dann direkt verwenden.

So in etwa würde die Funktion bei mir aussehen:

uint8_t autodetect (uint8_t *ocr, uint8_t *pre, uint16_t freq) {
 
    static uint16_t prescale[] = {1,8,32,64,128,256,1024}; //mögliche  Values für Timer2 lt Datenblatt...

    for (uint8_t i = 0; i < 7; i++) {
        uint32_t nenner = 2UL * prescale[i] * freq;
        if (nenner >= (F_CPU/256)) {
            *ocr = ((F_CPU+(nenner/2)) / nenner) - 1;
            *pre = i + 1;
            return 1;
        }
    }

    return 0;
}

Und im restlichen Code dann:

    uint8_t prescaler_index;
    uint8_t ocr_value;
    if (!autodetect(&ocr_value,&prescaler_index,isr_frequency))
        return 0;
    TCCR2 |= (prescaler_index<<CS20);
    OCR2 = ocr_value;

[PCMan]

Hi Sternst,
danke für den Input. Dass alle Variable uint32_t sind war reine Faulheit. Ich habe vorher, wie du geschrieben hast, alle Variablen auf die nötigen Größen reduziert gehabt. Allerdings hat die Rechnung dann Müll produziert und der Fehler schien durch die stupide Erweiterung aller Variablen auf 32 gelöst. Ich weiß, wahrscheinlich hat das das Problem nicht gelöst, sondern nur verschoben.

Gegenfragen:
Wenn ich die Integerdivision durchführe bekomme ich durchaus keine ganzzahligen Ergebnisse. Das ganze wird dann durch die Zuweisung an einen int ganzzahling gemacht. Da aber immer die Nachkommas dabei abgeschnitten werden wollte ich das mit round genauer machen. Wieso sollte das nix bringen?

in dem if-statement, welchen Vorzug bringt:

if (nenner >= (F_CPU/256))

gegenüber

if (F_CPU/nenner) <= 256

?

Kannst du mir bitte erklären, wie du auf diese Zeile kommst:

*ocr = ((F_CPU+(nenner/2)) / nenner) - 1;

Ich dachte lt. Datenblatt ist OCR = (F_CPU / (2 * Prescaler * Frequenz)) - 1

Wozu brauche ich bei dem prescaler index noch +1 und wozu das static?

Danke,
Simon

[sternst]

Ich habe vorher, wie du geschrieben hast, alle Variablen auf die nötigen Größen reduziert gehabt. Allerdings hat die Rechnung dann Müll produziert

Weil (wie ich schon schrieb) in dem Fall die Berechnungszeile etwas angepasst werden muss. Ohne Anpassung wird die Berechnung dann in uint16_t durchgeführt und läuft über. Man muss sie in uint32_t erzwingen, was in meinem Code das "UL" hinter der "2" erledigt.

und der Fehler schien durch die stupide Erweiterung aller Variablen auf 32 gelöst. Ich weiß, wahrscheinlich hat das das Problem nicht gelöst, sondern nur verschoben.

Ne, der Fehler ist damit tatsächlich behoben, nur halt unnötig aufwändig.

Wenn ich die Integerdivision durchführe bekomme ich durchaus keine ganzzahligen Ergebnisse.

Das ist schlicht falsch. Das Ergebnis einer Integer-Division ist wieder ein Integer (IMMER!), also ganzzahlig.

Da aber immer die Nachkommas dabei abgeschnitten werden wollte ich das mit round genauer machen. Wieso sollte das nix bringen?

Weil das Abschneiden nicht erst bei der Zuweisung passiert, sondern bereits bei der Division selber (siehe vorigen Quote). Das round() bekommt schon keine Nachkommastellen mehr zu sehen.

in dem if-statement, welchen Vorzug bringt:

if (nenner >= (F_CPU/256))

gegenüber

if (F_CPU/nenner) <= 256

Bei "F_CPU/256" sind beide Operanden Konstanten, daher wird die Division bereits beim Compilieren durchgeführt und durch die resultierende Konstante ersetzt. Bei "F_CPU/nenner" muss die Division zur Laufzeit durchgeführt werden.

Kannst du mir bitte erklären, wie du auf diese Zeile kommst:

*ocr  = ((F_CPU+(nenner/2)) / nenner) - 1;

Ich dachte lt. Datenblatt ist OCR = (F_CPU / (2 * Prescaler * Frequenz)) - 1

Richtig. Meine Zeile folgt genau aus der Formel, nur dass mit dem zusätzlichen Teil "+(nenner/2)" das Integer-Ergebnis gerundet wird (das was du mit round() versucht hast).

Wozu brauche ich bei dem prescaler index noch +1

Weil das Array mit "Index 0 = Prescaler 1" beginnt, während die Prescaler-Einstellung im Register mit "Index 0 = Timer gestoppt" beginnt.

wozu das static

Ohne das "static" wird das Array bei jedem Aufruf der Funktion neu angelegt und neu mit Werten befüllt. Da aber der Inhalt des Arrays in der Funktion ja gar nicht verändert wird, ist das unnötig. Mit dem "static" passiert das nur einmal am Anfang des Programms.

[PCMan]

Hi,

besten Dank, sehr eingebend.
Nur diese eine Zeile

*ocr = ((F_CPU+(nenner/2)) / nenner) - 1;

wurmt mich noch. In wie fern rundet man dort?

Mit nenner = 2UL*Prescaler*Frequenz ergäbe sich in der Zeile:
*ocr
= ((F_CPU + (2*Prescaler*Frequenz/2)) / 2*Prescaler*Frequenz) -1
= (F_CPU + Prescaler*Frequenz) / (2*Prescaler*Frequenz) -1
= (F_CPU/2*Prescaler*Frequenz + 1/2) -1;

oder hauen mich meine Mathe"kenntnisse" über's Ohr?

Ciao,
Simon

[sternst]

Nur diese eine Zeile

*ocr = ((F_CPU+(nenner/2)) / nenner) - 1;

wurmt mich noch. In wie fern rundet man dort?

"Eigentlich" müsste die Zeile so aussehen:

*ocr  = (F_CPU / nenner) - 1;

Um das Zwischenergebnis der Division zu runden, habe ich das "+(nenner/2)" hinzugefügt. Wie das funktioniert, kannst du leicht selber herausfinden. "A/B" im Vergleich zu "(A+(B/2))/B". Probiere es einfach mit ein paar Werten, dann siehst du sofort das Prinzip (wenn nicht, frag nochmal).

PS: Deine mathematische Umformung mag richtig oder falsch sein (habe ich mir nicht näher angeschaut), ist aber irrelevant. Denn dort wird nicht berücksichtigt, dass beim "/" der Nachkommaanteil "weggeschmissen" wird. Du kannst eine Integer-Rechnung mit "/" darin nicht einfach nach mathematischen Regeln umformen.
Einfaches Beispiel: "1/2" hat als Ergebnis 0. Du formst es mathematisch um in "1 - 1/2", und schon ist das Ergebnis 1.

[PCMan]

Besten Dank, sternst.
Wieder was gelernt.
Ciao,
Simon

[Bot-Builder]

Hallo Stefan,
Hallo Simon,

ich habe euren Thread hier interessiert verfolgt.

Den ocr_Wert über eine Funktion zu bestimmen ist für meinem Fall zu aufwendig. Ich brauche keine so weite Bandbreite an möglichen Frequenzen. Bei mir wechselt nur die Taktfrequenz vom ATMega. Ich wollte also den ocr_Wert mit einer Präprozessor #define berechnen. Und habe folgenden Code verwendet:

....

    //    CTC-Modus
    TIMSK |= (1 << OCIE0);

    //    ocr_Wert setzen
    #define        ocr_Wert        ((F_CPU/(2 * 1024 * 50))-1)
    //   #define        ocr_Wert        71
    #if ((Vergleichswert > 256) || (Vergleichswert < 0)) 
        #error "Fehler bei der Initialisierung Timer0!"
    #endif
    
    OCR0 = ocr_Wert;

....

Der aber fehlerhaft sein muss. Ich erhalte als Frequenz ca. 14hz, was bei einem Quarz mit 7,3728Mhz auf einen ocs_Wert von 255 schließen läßt.

Der übrigen Code ist aber richtig und funktionsfähig. Wenn ich #define ocs_Wert 71 schreibe (wie auskommendiert) erhalte ich exakt die gewünschten 50hz an einem Ausgangspin.

Das Problem hat vermutlich was mit der Berechnung zu tun: Weil der GCC warning: integer overflow in expression für die Zuweisung OCR0 = ocr_Wert; auswirft.

Präpozessor #defines sind reine Textersetzungen und keine eigenen Berechnungen. So weit klar. Aber der Ausdruck wird/sollte doch vom Compiler als Konstante gesehen werden und auch so gehändelt werden. Wird aber offensichtlich nicht. Des im Ausdruck mit uint16_t gerechnet wird, ist ebenfalls klar. Aber das Ergebniss ist doch eine uint8_t und müsste zu OCR0 passen. Habe ich mir jedenfalls so gedacht, was aber wie gesagt offensichtlich falsch ist. Auch alle Versuche den Ausdrucken Typen zu zu weisen, haben nichts gebracht.

Was mache ich dann da noch falsch? Hätte jemand eine Idee?

uint32_t nenner = 2UL * prescale[i] * freq;

@Stefan:
Die Wirkung von 2UL * habe ich zwar verstanden, die Hintergründe aber nicht wirklich. Wo kann man sich da mal schlau lesen? Hättest Du einen Tip für mich.

Auf alle Fälle schon mal vielen Dank.


mfg

Uwe