Poti Wert zu PWM Signal verarbeiten

Antonio schrieb:
> ADCSRA |= (1<<ADSC);  //Start conversions
>
>   //Setting ADC Input Pin to ADC0
>   ADMUX &= ~((1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (1<<MUX0));
>
>
>   //Setting reference to Avcc
>   ADMUX = (1<<REFS0);

Schlechte Idee. Setze immer erst die MUX und REF, bevor du die Wandlung 
startest. Steht auch so im Datenblatt.

Antonio schrieb:
> volatile double pwm_steps;

double? Warum sollte das ein Fliesskommawert mit sogar doppelter 
Präzision sein? Meinst du vllt. 'long'? Das wäre dann ein 32-bit Wert, 
aber immer noch viel zu gross. Auch hier reicht dicke ein 'unsigned 
int'. Allerdings tuns Bytes hier genauso, du wirst eine in 256 Stufen 
gedimmte LED nicht von einer in 65536 Stufen gedimmten unterscheiden 
können.

Antonio schrieb:
> unsigned int sensorWert1 = 512;
> unsigned int sensorWert2 = 0;
> unsigned int sensorWert3 = 0;

Auch diese Variablen müssen 'volatile' werden, da sie im Hauptprogramm 
und in der Timer ISR angesprochen werden. Zumindest sensorWert1 im 
Moment.

Antonio schrieb:
> TCCR0 |= /*(1<<CS01) | */(1<<CS00);

Wie jetzt? Wenn du keinen Vorteiler setzt, wird der Timer für immer 
gestoppt sein. Kriegst du bei dieser Syntax keinen Kompilierfehler?

Kannst Du dann nochmal den Code posten, so wie er jetzt ist?

Antonio schrieb:
> //Setting ADC Input Pin to ADC0
>   ADMUX &= ~((1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (1<<MUX0));
>
>   //Setting reference to Avcc
>   ADMUX = (1<<REFS0);

Das funktioniert zwar in diesem Fall, weil MUX0 bis MUX3 sowieso 0 sein 
sollen, aber Du meintest vermutlich:

   ADMUX |= (1<<REFS0);

Antonio schrieb:
> if(pwm_steps >= sensorWert1)
>   {
>     PORTB &= ~(1<<PB0);
>     pwm_steps = 0;
>   }
>   else
>   {
>     PORTB |= (1<<PB0);
>   }

Hier solltest Du meiner Meinung nach die Zeile "pwm_steps = 0;" 
weglassen.

Außerdem wird "sensorWert1" nirgendwo gesetzt - oder habe ich etwas 
übersehen? Die Funktion "saveAnalogWerte()" ist jedenfalls 
auskommentiert.

Wenn du Code übernimmst, dann übernimm ihn richtig!

1

ISR(TIMER0_OVF_vect)

2

{

3

  static int pwm_steps = 0;

4

5

  PORTB &= ~(1<<PB1);

6

  pwm_steps++;

7

  PORTB |= (1<<PB1);

8

9

  if(pwm_steps >= 1024) 

10

  {

11

    pwm_steps = 0;

12

  }

13

14

  if(pwm_steps >= sensorWert1)

15

  {

16

    PORTB &= ~(1<<PB0);

17

    pwm_steps = 0;

18

...

Nein. Du willst hier nicht pwm_steps auf 0 setzen.
pwm_steps zählt stur von 0 bis 1023 durch. Immer. Ständig. Ohne 
Ausnahme.
Und je nach Vergleichswert ist die LED eben nur bis zu diesem 
Vergleichswert eingeschaltet und den Rest aus. Durch Variation des 
Vergleichswertes variierst du das Verhältnis von Ein zu Aus. That's it. 
Das ist eine PWM.

>   ADCSRA |= (1<<ADIE);  //Enabling ADC Interrupt

Und wenn die den ADC Interrupt freigibst, brauchst du auch eine 
entsprechende ISR dafür.
Hast du keine -> wird mit einem µC-Reset bestraft.


Mach dir doch nicht das Leben so schwer. Im
AVR-GCC-Tutorial
gibt es wunderbare ADC Funktionen, die du nur benutzen musst.

Antonio schrieb:
> sensorWert1 wird ganz oben auf 9 gesetzt.
> volatile unsigned int sensorWert1 = 9;

Stimmt, habe ich übersehen. Sorry.

Antonio schrieb:
> Ich habe ursprünglich den COde so übernommen, wie er gepostet wurde,
> aber er funktionierte nicht

Hat aber einen anderen Grund.
Die ISR war so wie gepostet vollkommen in Ordnung,


Wenn du dir nicht sicher bist, dann mach halt nicht alles auf einmal. 
Wenn du mit PWM und ADC auf einmal überfordert bist, dann mach eines 
nach dem anderen.
Erst die PWM in Betrieb nehmen, testen.
Dann den ADC dazunehmen.

Dann klappts auch.

Karl Heinz Buchegger schrieb:
>>   ADCSRA |= (1<<ADIE);  //Enabling ADC Interrupt
>
> Und wenn die den ADC Interrupt freigibst, brauchst du auch eine
> entsprechende ISR dafür.
> Hast du keine -> wird mit einem µC-Reset bestraft.
>
>
> Mach dir doch nicht das Leben so schwer. Im
> AVR-GCC-Tutorial
> gibt es wunderbare ADC Funktionen, die du nur benutzen musst.

Genauer, sie sind hier

AVR-GCC-Tutorial/Analoge Ein- und Ausgabe: Nutzung des ADC

samt einem beispielhaften main(), das zeigt, wie man sie benutzt.

Aber bring erst mal die PWM alleine zum laufen! Du brauchst dazu erst 
mal keinen ADC.

Antonio schrieb:
> Das mit dem Interrupt wars, dankeschön :))
>
> Die Funktionen nutze ich absichtlich nicht, da es so hardwarenah wie
> möglich sein sollte (ist wichtig für das Projekt).

kopfschüttel.

Denkst du, die Funktionen machen irgendwas anderes, als das Chaos, das 
du da veranstaltet hast?

Antonio schrieb:

> Aber die Frequenz ist nicht hoch genug... die LED flackert (hab auch
> schon den Prescaler auf null gesetzt).... hmmm...


Wie wärs mal mit etwas rechnen?

Deine µC Taktfrequenz ist 1Mhz
Der Timer zählt bis 256 bis zum Overflow.
Du brauchst 1024 Overflows für einen PWM-Zyklus.

Wieviele PWM-Zyklen schafft der µC pro Sekunde?

1000000 / 256 = 3906
3906 / 1024 = 3.8

Das das flackert, wundert mich nicht.


Selbst wenn du den Mega auf 8Mhz intern geschaltet hast, sinds erst 30 
PWM-Zyklen pro Sekunde. Flackert immer noch. Du brauchst gut und gerne 
mindestens 60 oder 70. 100 wären noch besser.

Im Code steht: "# define F_CPU 8000000UL". Hast Du die Fuses wirklich 
richtig gesetzt? Läuft der Controller wirklich mit 8 MHz?

Wenn Du die PWM-Frequenz höher brauchst, nimm nicht den 
Timer-Overflow-Interrupt, sondern einen Timer-Compare-Match-Interrupt. 
Da kannst Du dann selber festlegen, bei welchem Timerstand der Interrupt 
ausgelöst werden soll.

Dass Antonio nichts daran liegt, die beste PWM-Methode zu nutzen, 
sondern dass er ausdrücklich Software-PWM machen will, ist Euch noch 
nicht aufgefallen? In einem der letzten Posts hat er sogar einen Grund 
dafür angegeben: Offenbar will er jemandem das Prinzip von PWM erklären, 
und dazu ist optimale Ausnutzen von Hardware-Möglichkeiten eher 
ungeeignet. Also warum reitet Ihr immer noch auf der Hardware-PWM herum?

Antonio schrieb:
> while(!(ADCSRA & (1<<ADSC)))
Andersrum.
while(ADCSRA & (1<<ADSC));
Denn das ADSC-Bit wird gesetzt und wenn er fertig hat, ist es 0.

Antonio schrieb:
> void ADC_SwitchChannel(int channel)
> {
>     if(channel == 0)
>     {
>       ADMUX &= ~((1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (1<<MUX0));
>     }
>     else if(channel == 1)
>     {
>       ADMUX &= ~((1<<MUX3) | (1<<MUX2) | (1<<MUX1));
>
>       ADMUX |= (1<<MUX0);
>     }
>     else if(channel == 2)
>     {
>       ADMUX &= ~((1<<MUX3) | (1<<MUX2) | (1<<MUX0));
>       ADMUX |= (1<<MUX1);
>     }
> }
Das geht auch mit weniger Aufwand. Nicht ohne Grund liegen die Mux-Bits
auf den unteren Bits im Register.

void AdcChannel(unsigned char channel)
{
   ADMUX &= ~((1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (1<<MUX0));
   ADMUX |= channel;
}
Und channel ist unsigned char und nicht int.

mfg.

Antonio schrieb:
> ADCSRA |= (1<<ADSC);
>   while(!(ADCSRA & (1<<ADSC)))
>   {
>   }

Hier liegt vermutlich der Wurm. ADSC ist 1, solange die Messung 
durchgeführt wird. Also müsstest Du die Abfrage so machen:

1

  while(ADCSRA & (1<<ADSC))

2

  {

3

  }

Da war ich jetzt ein paar Sekunden zu langsam ;-)

Antonio schrieb:
> Habs denk ich gelöst...
Gar nichts hast du gelöst.

Antonio schrieb:
> while(!(ADCSRA & (1<<ADIF)))

mfg.

Antonio schrieb:
> Herr Eckmann, das geht doch auch freundlicher nicht?
Das war freundlich. Lass mich erstmal unfreundlich werden.

Antonio schrieb:
> Mit meiner Lösung klappt es jedenfalls, mit Ihrer nicht.
Was klappt damit nicht?

Das jedenfalls ist totaler Humbug:
Antonio schrieb:
> ADCSRA |= (1<<ADSC);
>   while(!(ADCSRA & (1<<ADIF)))
>   {
>   }
>   ADCSRA |= (1<<ADIF);
>   sensorWert1 = ADCW;

mfg.

Antonio schrieb:
> Hab ich da was falsch verstanden?

Nee, ist schon richtig. Alternativ könntest du ADSC solange abfragen, 
bis es auf Null geht, dann ist die Wandlung auch fertig. Das hätte den 
Vorteil (nicht wirklich ein grosser), das du nicht extra ADIF löschen 
musst, spielt aber wirklich keine Rolle.

Antonio schrieb:
> while(!(ADCSRA & (1<<ADIF)));
Sorry. Das hatte ich übersehen.
Ja. Damit geht es auch.

mfg.

Das ADIF braucht man eigentlich nur, wenn ADIE gesetzt ist und der ADC 
über eine ISR, also mit Interrupts behandelt wird. Ansonsten ist das 
ADIF nur ein Hinweis darauf, dass eine ADC-Messung durchgeführt wurde. 
Deshalb ist mir ein wenig schleierhaft, wieso es mit dem Test auf ADIF 
geht, mit ADSC aber nicht, denn wenn ADSC nach dem Messvorgang wieder 
auf 0 geht, wird gleichzeitig ADIF auf 1 gesetzt.

Aber trotzdem habe ich noch zwei Punkte:

Erstens: Um das ADIF-Flag zu löschen, muss eine 1 in das Register 
geschrieben werden. Das geht NICHT mit

1

  ADCSRA |= (1<<ADIF);

sondern mit

1

  ADCSRA = (1<<ADIF);

Bei der ersten Zeile wird nämlich erst aus dem Register gelesen, dann 
der ursprüngliche Inhalt mit der 1 ODER-verknüpft, dann das Ergebnis 
zurückgeschrieben.

Zweitens: Wenn die Fertig-Meldung schon über ADIF gehen soll, würde ich 
die Reihenfolge ändern:

1) ADIF löschen
2) ADC starten
3) Warten bis ADC fertig ist, also bis ADIF 1 ist

Im Code schaut das dann so aus:

1

  ADCSRA = (1<<ADIF);

2

  ADCSRA |= (1<<ADSC);

3

  while(!(ADCSRA & (1<<ADIF)))

4

  {

5

  }

6

  sensorWertx = ADCW;

Edi R. schrieb:

> Erstens: Um das ADIF-Flag zu löschen, muss eine 1 in das Register
> geschrieben werden. Das geht NICHT mit
>

1

>   ADCSRA |= (1<<ADIF);

2

>

> sondern mit
>

1

>   ADCSRA = (1<<ADIF);

2

>

>
> Bei der ersten Zeile wird nämlich erst aus dem Register gelesen, dann
> der ursprüngliche Inhalt mit der 1 ODER-verknüpft, dann das Ergebnis
> zurückgeschrieben.


Und genau das will man hier in diesem Fall. Denn im ADCSRA Register sind 
nach andere Bits, die sich eben nicht ändern sollen und die sich nicht 
wie die Interrupt-Flags verhalten.
Also ist |= schon richtig.

Und genau deswegen ist die Abfrage von ADIF eine blöde Sache. Vor allen 
Dingen deshalb, weil es keiner braucht.

Zum starten des ADC setzt man das ADSC Bit und wenn der ADC fertig ist, 
dann zieht er es wieder zurück auf 0. Was könnte einfacher sein?

Aber solange Antonio das Rad ständig neu erfinden will, redet man 
dauernd aneinender vorbei.

(Wenn mir schon einer mit so einem Scheiss kommt, dass er die Funktionen 
aus dem Tutorial nicht benutzen will, dann hab ichs schon dicke. 3 
Stunden Gehampel für nichts und wieder nichts.)