www.mikrocontroller.net

Forum: Compiler & IDEs mit Optimieung im Compiler fehler bei while Schleife


Autor: Mario (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich bräuchte einen Tipp:

Ein bischen code fehlt noch, aber das Problem ist das mit 
eingeschalteter Optimierung am Compiler der Prozessor in der while 
Schleife fest hängt und die Bedingung nicht mehr vergleicht. Ohne 
Optimierung läuft es.

  TIMSK |= (1 << TOIE2);        // Timer2 Overflow Interrupt frei

ISR(TIMER2_OVF_vect)
{
timer2++;
}

int warteschleife (oft) {          // Timer 2 gesteuerte Warteschleife
TCNT2=0b00000000;              // Timer 2 Zähler Reset
TCCR2=0b00000101;              // Timer 2 Prescaler / 128

  while (timer2<oft) {          // Schleife
  ;
  }

timer2=0;                  // Schleife zurücksetzen
TCCR2=0b00000000;              // Timer 2 Zähler Reset
TCNT2=0b00000000;              // Timer 2 Prescaler/Timer aus

return 0;
}

wie könnte ich es zum laufen bekommen ?

viele Grüße
Mario

Autor: Sven P. (haku) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
timer2 muss volatile sein.

Autor: Mario (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ist volatile, funkioniert nicht, nur wenn die Compileroptimierung aus 
ist.

timer2 zählt über "oft" hinaus, habe ich mit printf ausgegeben und 
getestet.

Autor: holger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Ein bischen code fehlt noch, aber das Problem ist das mit

Dann mach den Code komplett und stell dann deine Frage.

>int warteschleife (oft) {          // Timer 2 gesteuerte Warteschleife

Da ballert dir der Compiler eins rein.

Was soll dieser Unsinn mit irgendwelchen Pseudocodes
die sich nicht einmal kompilieren lassen?

Autor: Mario (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hier compilierbar:

#include <avr/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <avr/interrupt.h>
//#define F_CPU 8000000UL  // 8 MHz


int volatile timer2;


ISR(TIMER2_OVF_vect)
{
timer2++;
}



int main (void)
  {

  // Digitale Ausgänge definieren
  PORTB |= (1 << DDB0);
    DDRB |= (1 << DDB0);                          //0 LED Störung



//Vereinfachung Ausgänge
#define StoerungEIN (PORTB &= ~( ( 1 << PB0 ) ))
#define StoerungAUS PORTB |= (1<<PB0)


  TIMSK |= (1 << TOIE2);        // Timer2 Overflow Interrupt frei

  sei();                    // Interrupts Global einschalten


warteschleife(1000);
StoerungEIN;
}



int warteschleife (oft) {          // Timer 2 gesteuerte Warteschleife
TCNT2=0b00000000;              // Timer 2 Zähler Reset
TCCR2=0b00000101;              // Timer 2 Prescaler / 128



  while (timer2<oft) {          // Schleife
  ;
  }
//StoerungEIN;                // zum testen

timer2=0;                  // Schleife zurücksetzen
TCCR2=0b00000000;              // Timer 2 Zähler Reset
TCNT2=0b00000000;              // Timer 2 Prescaler/Timer aus

return 0;
}

Autor: holger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>hier compilierbar:
>int warteschleife (oft) {          // Timer 2 gesteuerte Warteschleife

Träum weiter.

Autor: Mario (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
dein Kommentar hilft mir nicht weiter, ich würde nicht umsonst hier 
fragen. Ich weiß nicht was du meinst.

Autor: Andreas W. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Datentyp von oft ?

Autor: Mario (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wingcc macht daraus ein int

../test.c:43: warning: type of 'oft' defaults to 'int'

Autor: Sven P. (haku) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mario wrote:
> hier compilierbar:
blablabla

> int volatile timer2;
Oki.

> ISR(TIMER2_OVF_vect)
> {
> timer2++;
> }
Auch ok, wenn auch ungünstig.

> int main (void)
>   {
>
>   // Digitale Ausgänge definieren
>   PORTB |= (1 << DDB0);
>     DDRB |= (1 << DDB0);                          //0 LED Störung
>
> //Vereinfachung Ausgänge
> #define StoerungEIN (PORTB &= ~( ( 1 << PB0 ) ))
> #define StoerungAUS PORTB |= (1<<PB0)
>
>
>   TIMSK |= (1 << TOIE2);        // Timer2 Overflow Interrupt frei
Oki.


>   sei();                    // Interrupts Global einschalten
Wichtig.

> warteschleife(1000);
> StoerungEIN;
> }
Jo.


> int warteschleife (oft) {          // Timer 2 gesteuerte Warteschleife
Klassisches C nimmt per Standard "int" als Datentyp an, wenn nix 
drannesteht grübel

> TCNT2=0b00000000;              // Timer 2 Zähler Reset
> TCCR2=0b00000101;              // Timer 2 Prescaler / 128
Timer läuft los.

>   while (timer2<oft) {          // Schleife
>   ;
>   }
> //StoerungEIN;                // zum testen
>
> timer2=0;                  // Schleife zurücksetzen
Wie wärs denn, wennde den zurücksetz, bevor du anfängs, ihn 
hochzuzählen? Und: Warum nochn Timer? In TCNT2 wird doch schon gezählt.

> TCCR2=0b00000000;              // Timer 2 Zähler Reset
> TCNT2=0b00000000;              // Timer 2 Prescaler/Timer aus
>
> return 0;
> }
Jo.

Autor: Johann L. (gjlayde) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mario wrote:
>
> wie könnte ich es zum laufen bekommen ?
>

Wenn ich mir den Code so anschau, solltest Du erstmal die Frage lösen

"Wie könnte ich es zum Compilieren bekommen?"

Autor: Schwurbl (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Schreib' mal 'volatile int' statt 'int volatile'. Der Modifier ist so 
evtl. wirkungslos.

Autor: Chris (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Schreib' mal 'volatile int' statt 'int volatile'. Der Modifier ist so
> evtl. wirkungslos.

Nein, das macht hier keinen Unterschied. Einen Unterschied kann die 
Position des Qualifiers (so nennt der Standard das) eigentlich nur bei 
Zeiger-Deklarationen machen:
volatile int* x1;  // (1)
int volatile* x2;  // (2)
int * volatile x3; // (3);
Deklarationen (1) und (2) haben die gleiche Bedeutung, (3) ist anders. 
Bei (3) bezieht sich das volatile im Gegensatz zu (1) und (2) auf den 
Zeiger selbst und nicht auf das, worauf der Zeiger zeigt.

Der Punkt ist aber, dass (1) und (2) absolut gleichwertig sind, kein C- 
oder C++-Compiler darf diese Typen als unterschiedlich ansehen.

Autor: jl (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wie siehts denn mit dem assembler output (lst - file) aus?

der gibt zusätzlich bestimmt nützliche Infos was der Compiler 
drausmacht.



JL

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.