Pwm über Poti mit Mega8 in Bascom

Hi,

keine große Sache und als Einsteigerprojekt geeignet....

Neben dem Stichwort PWM musst du dich mit der Sache ADC vertraut machen, 
denn was du eigentlich brauchst ist:

Ein Poti welches die Spannung auf den ADC gibt.
Eine Firmware, die den Registerwert des ADCs in das Register der PWM 
schiebt.
Eventuell durch 4 Teilen falls du 8Bit PWM bei 10Bit ADC nutzt...

Sitze leider gerade am falschen PC sonst würde ich dir ein Code Snippet 
mitschicken...

Gruß
Jochen

EazyEddy schrieb:

> ist. Auf überhebliche oder ironische Antworten wird verzichtet.

Kein Problem.
Nur ist die Aussage 'immense Probleme' nicht wirklich hilfreich 
festzustellen, wobei du Probleme hast.

Welche Teile kannst du alleine?
* PWM (und über welche PWM [Bitzahl] reden wir eigentlich?)
* ADC auslesen

und recht viel mehr brauchst du ja auch nicht.

EazyEddy schrieb:
> Auf überhebliche oder ironische Antworten wird verzichtet.
Ebenso auf eine konkrete Problembeschreibung oder gar ein Schaltplan.
Wie soll dir also jemand helfen?

Kann man nur sagen:
1. gehe auf google
2. tippe "bascom tutorial" ein
3. drücke return
4. such dir einen passenden Link aus und lerne

Wenn du nur pwm machen willst könntest du auch einen multivibrator mit 
variablen tastverhältnis aufbauen.

EazyEddy schrieb:
> Bei 100%:
> 1023/204=5,01470882352941*204=1023
> Bei 50%:
> 512/204=2,509803921568627*204=512
>
> Und wo hat sich jetzt der fail versteckt? xD

Ich geb dir eine Analogie. Denn eben weil das so wichtig ist, musst du 
selbst drauf kommen.

Angenommen du hättest Zahlen von 1 bis 100

0, 1, 2, 3, 4, 5, ...,, 98, 99, 100

Die dividierst du jetzt erst mal durch 10. Und zwar ganzzahlig! Also 
keine Kommastallen.

Alle Zahlen von 0 bis 9 ergebn, wenn man sie durch 10 dividiert eine 
glatte 0.

Alle Zahlen von 10 bis 19 ergeben eine glatte 1
Alle Zahlen von 20 bis 29 ergeben eine glatte 2
....

soweit klar?

Wenn du nun dieses Zwischenergebnis wieder mit 10 multiplizierst, was 
ergibt sich dann.
Nun 0 mal 10  ist wieder 0
    1 mal 10  ist wieder 1
etc.

Das sollte auch klar sein. Bis hier her ist alles trivial.

Und jetzt fügen wir das alles mal zusammen

Ausgangszahl   / 10   Zwischenergebnis    * 10     Endergebnis
---------------------------------------------------------------
  0                        0                             0
  1                        0                             0
  2                        0                             0
...
  9                        0                             0
 10                        1                            10
 11                        1                            10
 12                        1                            10
...
 19                        1                            10
 20                        2                            20
 21                        2                            20
...
 29                        2                            20
 30                        3                            30
 31                        3                            30
...

merkst du was?

Durch das dividieren durch 10 (ohne Kommastellen) und anschliessende 
Multiplizieren mit 10, hast du etwas erreicht. Nämlich alle Zahlen von 0 
bis 9 ergeben geschlossen 0. Alle Ausgangszahlen von 10 bis 19 ergeben 
geschlossen 10, usw. usw.

Was du also gemacht hast: Du hast die Ausgangszahlen von 0 bis 99 in 10 
Bereiche eingeteilt, wobei die Bereiche auch wieder von 0 bis 90 laufen, 
aber die Ausgangszahlen sauber in diese Bereiche eingepasst werden.

Edit:

Und nein. Du musst nicht durch die gleiche Zahl dividieren mit der du 
auch multiplizierst. Indem du die beiden Zahlen geeignet wählst, kannst 
du auch den Zahlenbereich 0 bis 1023 (die Werte, die du vom ADC 
bekommst) zb in den Wertebereich 0 bis 255 (so wie sie eine 8 Bit PWM 
haben will) umrechnen, wobei sich eine von dir gewünschte Anzahl an 
'Stufen' ergibt.


> 1023/204=5,01470882352941*204=1023
> 512/204=2,509803921568627*204=512

Dein Fehler besteht darin, dass du ganz automatisch davon ausgehst, dass 
in einem Computer alles mit Nachkommastellen gerechnet wird. Dem ist 
aber nicht so.

Du hast das Problem, dass so viele haben.

Du willst nich wahrhaben, dass man erst mal mit den Grundlagen anfangen 
muss, ehe man sein erstes reales Projekt macht.

EazyEddy schrieb:
> Karl Heinz Buchegger schrieb:
>> Dein Fehler besteht darin, dass du ganz automatisch davon ausgehst, dass
>> in einem Computer alles mit Nachkommastellen gerechnet wird. Dem ist
>> aber nicht so.
>
> Es ist mir schon bewusst. War eben nur ein dummer fehler von mir.
> Programmier jetzt schon über 1 Woche an der Pwm rum und mein Kopf lässt
> mich langsam im Stich.

Hinweis.
In meiner Tabelle findet sich die Anzahl der Stufen bei dem 
Zwischenergebnis wieder.

Wenn du also 5 Stufen haben willst, dann sorg dafür dass dein 
Zwischenergebnis aus den Zahlen 0, 1, 2, 3, 4 bestehen kann und aus 
sonst nichts. Wenn also der ADC Werte von 0 bis 1023 liefert, wodurch 
musst du diesen Wert dividieren, damit da nur die Zahlen 0, 1, 2, 3, 4 
rauskommen können? (Dazu gehst du am besten von der Zahl 1024 aus und 
verusuchst die so zu dividieren, dass da 5 rauskommt. Denn du willst ja 
haben, dass sich deine 5 Bereiche gleichmässig auf die ADC Werte 
verteilen)

Hast du dein Zwischenergebnis, dann wird von dort auf die PWM 
umgerechnet. Die PWM-Stufe (ich geh jetzt mal von einer 8-Bit PWM aus) 
möchte Werte von 0 bis 255 (weil sie ja 8 Bit ist). Du hast die Zahlen 
0, 1, 2, 3, 4. Womit musst du die daher multiplizieren, damit sich 
daraus Zahlen ergebn die im Bereich 0 bis 255 liegen? (Wieder: womit 
musst du 5 multplizieren, damit da möglichst 256 rauskommt. Denn auch 
wieder: du willst eine gleichmässige Aufteilung).


Übrigens: Mit Excel lässt sich am PC das alles ganz wunderbar für jede 
einzelne Zahl, die vom ADC kommen kann, erst mal durchspielen. Da kannst 
du dir für jede Zahl ansehen, was bei deiner Berechnung rauskommen wird 
(und natürlich auch die Zwischenwerte, damit du auch verfolgen kannst, 
wie sich das Endergebnis ergibt)

EazyEddy schrieb:
> Limloz schrieb:
>> wenn man die sinnlose Rechnerei kürzt steht da:
>> Pwm1b = Getadc(0)
>
> Das lässt aber komischer weise nicht kompilieren.

Tja. das ist BASCOM.
Das hat so seine Schwächen wenn es um die Formulierung von Berechnungen 
geht. In einer anderen Programmiersprache wäre das kein Problem.


> Nur das geht:
>
> Analogwert = Getadc(0)
> Pwm1b = Analogwert

Das ist aber im eigentlichen Sinne nicht das was du willst. Du wolltest 
ja 5 PWM Bereiche haben. So geht die Potistellung 1:1 auf die PWM durch 
und du hast keine Bereiche. Die PWM wird natürlich mit der Potistellung 
mitgehen, aber eben in genau der Abstufung, die du vom ADC hast. Also 
1024 Bereiche und nicht 5.
Wenn du 5 Bereiche haben willst, dann musst du die Zahlen so bearbeiten, 
dass sich das ergibt. Das Handwerkszeug dazu hast du ja jetzt. Im Grunde 
besteht der Trick darin, dass man bei der Division die Nachkommastellen 
wegfallen lässt. Das ist der entscheidende Punkt, der diese Umrechnung 
möglich macht.

Limloz schrieb:
> EazyEddy schrieb:
>> Limloz schrieb:
>>> wenn man die sinnlose Rechnerei kürzt steht da:
>>> Pwm1b = Getadc(0)
>>
>> Das lässt aber komischer weise nicht kompilieren.
>> Nur das geht:
>>
>> Analogwert = Getadc(0)
>> Pwm1b = Analogwert
>
>
> Das soll ja nicht die Lösung für dein Problem sein, sondern durch kürzen
> lediglich aufzeigen, dass deine Rechnerei keine Skalierung durchführt.

Nur das in seinem Beispiel

>Analogwert = Getadc(0)
>Analogwert = Analogwert / 204
>Pwm1 = Analogwert * 204
>Pwm1b = Pwm1

die 'sinnlose' Rechnerei durchaus einen Effekt hat und somit ganz und 
gar nicht sinnlos war.

EazyEddy schrieb:
> Karl Heinz Buchegger schrieb:
>> Dazu gehst du am besten von der Zahl 1024 aus und
>> verusuchst die so zu dividieren, dass da 5 rauskommt.
>
> Wenn ich 1024 durch 5 dividiere komme ich auf 204,8 (204).
>
> Und da haben wir schon wieder dieses dämliche komma. -.-

Das musst du ignorieren :-)
Denn dein Rechner tut es auch.

EazyEddy schrieb:
> Karl Heinz Buchegger schrieb:
>> Das musst du ignorieren :-)
>> Denn dein Rechner tut es auch.
>
> Dann war der Ansatz hier schon gar nicht mal so falsch oder?

:-)
Du bist der Programmierer. Du entscheidest :-)
(Und dann siehst du auch gleich, ob du das was ich dir weiter oben zu 
vermitteln veruscht habe, auch verstanden hast)

>          /204  *204
> 0-203     = 0  =  0
> 204-407   = 1  = 204
> 408-611   = 2  = 408
> 612-815   = 3  = 612
> 816-1019  = 4  = 816
>(1020-1023 = 5  = 1020)?

Na das sieht doch schon prinzipiell gut aus!

Jetzt musst du nur noch überlegen, ob das deine Forderung
> 0%, 25%, 50%, 75% und 100%
erfüllt oder nicht, bzw. wie du die Zahlenwerte anpassen musst, damit es 
das tut.

Du willst wahrscheinlich

1

  ADC        0  ...................  ...............                     1023

2

  -----------------------------------------------------------------------------

3

  PWM in %   0  0  0  ... 25 25 25 ...  50 50 50 ... 75 75 75 ... 100 100 100

4

  PWM als Wert  0     ...   256    ...     512   ...   768    ...    1023

und dafür musst du jetzt eine Umrechnung finden, so dass die 100% PWM 
nicht erst bei einem ADC Wert von 1023 erreicht werden sondern schon 
früher.
Denn die 100% sollen ja wahrscheinlich nicht erst dann kommen, wenn du 
das Poti an den rechten Anschlag gedreht hast, sondern die Stufen sollen 
sich gleichmässig auf den Potiweg verteilen. Aber vielleicht sollen sie 
das auch nicht - du bist der Programmierer, du entscheidest. Wie immer 
du das haben willst, das ist per Definition richtig.

EazyEddy schrieb:
> Karl Heinz Buchegger schrieb:
>> Jetzt musst du nur noch überlegen, ob das deine Forderung
>>> 0%, 25%, 50%, 75% und 100%
>> erfüllt oder nicht, bzw. wie du die Zahlenwerte anpassen musst, damit es
>> das tut.
>
> sieht mir eher nach 0,20,40,60,80,100 aus, da es jetzt von 0 bis 5 geht
> statt von 0 bis 4^^
>
> Aber ich komme lagsam dahinter. Danke.

Ich bin sicher du kriegst es jetzt alleine hin.

Und du hast sicher auch schon eines bemerkt: Es hilft, wenn man sich 
neben die Tastatur einen Zettel und Bleistift legt, mit dem man solche 
Zahlenspielereien durchprobieren kann :-)

Das glauben nämlich viele auch nicht. Aber in der Programmierung ist 
Vorbereitung das halbe Leben. Wenn ich etwas nicht mit Papier und 
Bleistift lösen kann, kann ich es auch nicht programmieren. Papier und 
Bleistift haben aber den Vorteil, dass ich leicht die Dinge variieren 
kann und mir an konkreten Zahlen die Dinge verdeutlichen kann. Und zwar 
in meiner Sprache, zb in Form von Diagrammen oder in Form von Tabellen, 
und nicht in einer abstrakten Programmiersprache.