Endlosschleife

[Kilian H. (qwert)]

Hallo,

ich versuche gerade, einen PWM zu programmieren. Nur zu Testzwecken habe 
ich folgenden Codeabschnitt programmiert:

int main(void) {
  double X, Xold, Xp, Xd, P, D;

  P = 0.1;
  D = 60;

  DDRB = 0xff;
  PORTB = 0x00;
  
  ADMUX = (1<<REFS0);
  ADCSRA = (1<<ADEN)|(1<<ADPS2);

  TCCR0 = (1<<CS00);
  TIMSK = (1<<TOIE0);

  sei();


  while(1) {    
    pwm = 128;
...

Setze ich die lezte Zeile "pwm = 128" vor die while-Schleife, so 
funktioniert meine Regelung. In der while-Schleife aber nicht mehr.

Ich habe leider überhaupt keine Idee an was das liegen könnte.

Vielen Dank für eure Unterstützung! :)

[Nicolas S. (Gast)]

Welche Farbe hat denn die Tischdecke?

[Peter II (Gast)]

Kilian Herbst schrieb:
> Ich habe leider überhaupt keine Idee an was das liegen könnte.

wenn es spannend wird, ist leider der sichtbare code zu ende.

[Rene H. (Gast)]

Zeig mal bitte die ganze while Schleife.

Grüsse,
René

[Magnus M. (magnetus)]

Kilian Herbst schrieb:
>   while(1) {
>     pwm = 128;
> ...
>
> Setze ich die lezte Zeile "pwm = 128" vor die while-Schleife, so
> funktioniert meine Regelung. In der while-Schleife aber nicht mehr.

Der Rest der while() wäre interessanter.

Dadurch dass die Zuweisung innerhalb der while() steht, wird der 
Variable "pwm" zu Beginn jedes Durchlaufes erneut der Wert 128 
zugewiesen. Vermutlich willst du aber eben diese Variable stetig ändern.

[Marc (gierig)]

Kilian Herbst schrieb:

> Setze ich die lezte Zeile "pwm = 128" vor die while-Schleife, so
> funktioniert meine Regelung. In der while-Schleife aber nicht mehr.

Denkst du nicht das der Rest des Codes auch Interesant ist ?

[Kilian H. (qwert)]

Der Rest der while-Schleife:

    for(int i=0; i< 8;i++) {
      X =  X + ADC_Read();
    }
    X = X/8;
    if(X < 512) X = 512;
    Xp = X - 512;
    Xp = Xp * P;
    
    Xd = X - Xold;
    Xold = X;
    Xd = Xd * D;
  
    Y = Xp + Xd;
    Y = Y/2;
    
    if(Y > 255) Y = 255;
    if(Y < 0) Y = 0;

Den habe ich nicht mit gepostet, weil der an der Variable pwm nichts 
ändert. (soll er natürlich in der Endversion dann schon machen)

Wenn ich in die Main-Methode einfach nur pwm=128; schreibe, funktioniert 
es - die Leuchtdioden blinken also. Schreibe ich aber:

while(1) { pwm = 128;}

Dann geht gar nichts, die LEDs bleiben aus.

[Nicolas S. (Gast)]

Ich habe schon lange keinen Quelltext mehr gesehen, der mit "int(main)" 
anfängt.

[Peter II (Gast)]

Kilian Herbst schrieb:
> Wenn ich in die Main-Methode einfach nur pwm=128; schreibe, funktioniert
> es - die Leuchtdioden blinken also. Schreibe ich aber:while(1) { pwm =
> 128;}
>
> Dann geht gar nichts, die LEDs bleiben aus.

wie wissen nicht wo PWM überhaupt verwendet wird. Wenn wir das nicht 
sehen das können wir nicht helfen.

[Nicolas S. (Gast)]

P.S.: Zumindest keinen, der funktioniert.

[Marc (gierig)]

> while(1) { pwm = 128;}

Wenn du das so schreibst kein wunder, die Schleife wird
ja nie verlassen.

die PWN var taucht in deinem Codefragmentauch nicht wieder auf
und ist auch nirgentwo definiert/declariert.
Also auch unötig und kann wegbleiben.


Kilian Herbst schrieb:
> Der Rest der while-Schleife:

BITTE, den ganzen code, mit allen drum und dran. Keine Fragmente
oder einzelne Zeilen Stück für Stück preisgeben.

[Magnus M. (magnetus)]

- Wie sieht dein TOIE0 Interrupthandler aus?
- ist "pwm" als volatile deklariert?

[Kilian H. (qwert)]

Ok, hier der ganze Quelltext ;): Teilweise habe ich den aus dem 
avr-Tutorial genommen. Das mit dem int(main) habe ich hieraus:
http://www.kreatives-chaos.com/artikel/codeschnipsel-avr-gcc

Ich weiß, dass ADC_init() nicht aufgerufen wird, das sollte aber mein 
Problem nicht beeinträchtigen.

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <stdint.h>
#include <avr/interrupt.h>


uint8_t pwm = 0, cnt = 0;
uint16_t Y = 0;

void ADC_Init(void) {
 
  uint16_t result;
 
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = (1<<REFS0);    
  // oder interne Referenzspannung als Referenz für den ADC wählen:
  // ADMUX = (1<<REFS1) | (1<<REFS0);
 
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  // schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung 

warten
  }
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
     Wandlung nicht übernommen. */
  result = ADCW;
}

uint16_t ADC_Read()
{
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

int main(void) {
  double X, Xold, Xp, Xd, P, D;

  P = 0.1;
  D = 60;

  DDRB = 0xff;
  PORTB = 0x00;
  
  ADMUX = (1<<REFS0);
  ADCSRA = (1<<ADEN)|(1<<ADPS2);

  TCCR0 = (1<<CS00);
  TIMSK = (1<<TOIE0);

  sei();

  while(1) {
                pwm = 128;
    for(int i=0; i< 8;i++) {
      X =  X + ADC_Read();
    }
    X = X/8;
    if(X < 512) X = 512;
    Xp = X - 512;
    Xp = Xp * P;
    
    Xd = X - Xold;
    Xold = X;
    Xd = Xd * D;
  
    Y = Xp + Xd;
    Y = Y/2;
    
    if(Y > 255) Y = 255;
    if(Y < 0) Y = 0;
  }

  return 0;
}

ISR (TIMER0_OVF_vect) {
  uint8_t temp = 0x00;
  cnt++;
  if(cnt == 0xff)
    cnt = 0;
  if(cnt < pwm)
    temp = 0xff;
  PORTB = temp;
}

[ich (Gast)]

Deklariere mal pwm als volatile...

[Kilian H. (qwert)]

Das war die Lösung! Vielen Dank! :)

[Falk B. (falk)]

zum Thema volatile, siehe Interrupt

[Martin K. (maart)]

Kilian Herbst schrieb:
> Das war die Lösung! Vielen Dank! :)

Perfekt! Und den int main(void)-Unken kann man klammheimlich den 
Mittelfinger zeigen.

[Nicolas S. (Gast)]

Martin Kreiner schrieb:
> Und den int main(void)-Unken kann man klammheimlich den
> Mittelfinger zeigen.

Wenn Dich das glücklich macht. Wobei Du zugeben must, daß der Fehler im 
Quelltext erst dann gefunden wurde, als er nicht mehr mit "main" sondern 
mit den Includes anfing.

[Kilian H. (qwert)]

Falk Brunner schrieb:
> zum Thema volatile, siehe Interrupt

Danke, aber volatile und co. ist mir hinlänglich aus Java bekannt :), 
hab nur in dem anderen Kontext das Problem völlig vergessen.

[Magnus M. (magnetus)]

Kilian Herbst schrieb:
> uint16_t Y = 0;
(...)
>     if(Y < 0) Y = 0;

Dieses "if" ist übrigens für den Allerwertesten.

[Peter S. (psavr)]

>Kilian Herbst schrieb:
>> uint16_t Y = 0;
>(...)
>>     if(Y < 0) Y = 0;
>
>Dieses "if" ist übrigens für den Allerwertesten.
Das merkt der Compiler zum Glück  selber und schmeisst den unnötigen 
Code gleich in den Mülleimer.