Unsigned Integer Wert auf 100er Runden

Woran verzweifelst Du konkret? Anhand der Erwähnung von unsigned int 
gehe ich mal davon aus, dass es sich um C handelt, wobei eine explizite 
Erwähnung der Programmiersprache eigentlich zu den 
Selbstverständlichkeiten gehört. Und eine Rundung ist in C eigentlich 
kein Problem, allerdings müsstest Du dazu schon mal ein paar 
Randbedingungen rausrücken...

gerundet = ((wert + 50)/100)*100;

fertig!

Edit: wenn die Werte nicht so sehr schwanken sollen, dann wäre 
vielleicht auch ein Filter angebracht. Denn ist der Messwert um 24100 
herum, so schwankt es wieder hin und her.

Ja genau es handelt sich un C, hatte ich vergessen zu erwähnen.

Das Problem ist, dass ich keinen float-Wert auf "x" Kommastellen runden 
möchte, sondern wie in dem Beispiel angegeben einen unsigned int in 
100er Schritten.

Der Wert der sich also in der Variablen befindet beträgt wie im Beispiel 
24113. Nun würde ich diesen Wert gerne so runden, dass anschließen 24100 
in der Variablen steht.

Fehlt sonst noch etwas?

Da Kn wrote:
> Das Problem ist, dass ich keinen float-Wert auf "x" Kommastellen runden
> möchte, sondern wie in dem Beispiel angegeben einen unsigned int in
> 100er Schritten.
Schön, die Lösung hat Karl ja mittlerweile geliefert...

sorry, wenn der wert um 24150 herum liegt....

Karl Zeilhofer wrote:
> gerundet = ((wert + 50)/100)*100;
>
> fertig!
>
> Edit: wenn die Werte nicht so sehr schwanken sollen, dann wäre
> vielleicht auch ein Filter angebracht. Denn ist der Messwert um 24100
> herum, so schwankt es wieder hin und her.

Stimmt das klappt. Das Problem ist, dass ich wahrscheinlich keine Zeit 
für eine weitere Multiplikation und Division habe.

Karl Zeilhofer wrote:
> Edit: wenn die Werte nicht so sehr schwanken sollen, dann wäre
> vielleicht auch ein Filter angebracht. Denn ist der Messwert um 24100
> herum, so schwankt es wieder hin und her.
Richtig, eine Rundung glättet nur unzureichend. Glätten kann man mit 
einer (vernünftigen) Mittelwertbildung.

Auf welcher Hardware arbeitest du?

Da Kn wrote:
> Stimmt das klappt. Das Problem ist, dass ich wahrscheinlich keine Zeit
> für eine weitere Multiplikation und Division habe.

Dann runde halt nich im Dezimalen, sondern im Binären mit Shift. Sieht 
zwar nicht so schön aus, erfüllt aber den Zweck...

Da Kn wrote:
> Stimmt das klappt. Das Problem ist, dass ich wahrscheinlich keine Zeit
> für eine weitere Multiplikation und Division habe.
Ach, guck mal da. Genau das sind die Randbedingungen, die Du oben 
verschwiegen hast. Dazu gehört neben der Programmiersprache auch, was 
für Ressourcen Dir zur Verfügung stehen. So langsam kommt es also 
raus...

Der nächste Punkt (nachdem Du Deine Hardware mal beschrieben hast) wäre 
jetzt die Frage, was mit den gerundeten Werten überhaupt geschehen soll. 
Eine Multiplikation (Division) mit (durch) eine(r) Konstante benötigt 
auf den meisten Systemen übrigens gar nicht so viel Zeit. Wenn es nicht 
grad um Mikrosekunden geht, ist das relativ unkritisch. Aber wie schon 
gesagt: Das hängt von den verdammten Randbedingungen ab, die bislang nur 
Du selbst kennst!

Also bei dem Controller handelt es sich um einen MSP430F2272, der mit 
einer Taktfrequenz von 16Mhz läuft.

Es sollen 3 Werte in 100er Schritten gerundet werden. Ich habe jetzt 
gerade nocheinma nachgemessen. Für die Rundung eines Wertes über das 
Verfahren was Karl vorgeschlagen hatte benötige ich für einen Wert eine 
Zeit von ca 30us.

Ich könnte mich mit einer Zeit von maximal 10us anfreunden.

Nee nee das mit der UART geht nicht.
Ich muss die Werte vorher im Controller gerundet haben.

Tim T. wrote:

> Randbedingung: Nur Positive Messwerte.

Weitere Randbedingung: funktioniert nur, wenn der Messwert kleiner 100 
ist. Man kann mit dieser Methode also Messwerte kleiner 100 zu 0 oder 
100 runden.
Man bräuchte schon noch zusätzlich ein Modulo, und das braucht dann 
wieder signifikant Zeit.

> Addiere 50 auf deinen Messwert.
> Wenn Messwert größergleich 100 ist,
>  setze die beiden letzten stellen 0.
> Sonst
>  setze Messwert 0.
>
>
> Randbedingung: Nur Positive Messwerte.


Soweit logisch:

1

Wert = Wert + 50;

2

if(Wert >= 100)

3

   //setze letzten 2 stellen auf 0;

4

else

5

   Wert = 0;

Aber wie setze ich in C die letzten zwei Stellen auf 0?

Da Kn wrote:

> Soweit logisch:

Nö, denn die Methode rundet bei den meisten Werten (alle größer 100) 
nicht, sondern streicht nur die letzten beiden Stellen.

> Aber wie setze ich in C die letzten zwei Stellen auf 0?

Indem du den Modulo 100 abziehst.

Für ein korrektes Funktionieren dieser Methode bräuchte man also zweimal 
den Modulo-Operator. Dürfte (wenn überhaupt) nur unwesentlich schneller 
sein, wie einmal * und einmal /.

Korrektur, man kommt natürlich auch mit nur einmal Modulo aus:

1

rest = wert % 100;

2

wert -= rest;

3

if (rest >= 50)

4

    wert += 100;

Du kannst zum wert 50 addieren, in einen String printen (sprintf()), und 
dort die entsprechenden Zeichen auf '0' setzen.
Diesen String sendest du dann per UART.

Das mit dem Modulo klappt bringt aber nicht wirklich eine Zeitersparnis.

Als String printen ist keine Lösung für mich, muss es mit dem unsigned 
int Wert machen.

Karl Zeilhofer wrote:
> Da Kn wrote:
>> Stimmt das klappt. Das Problem ist, dass ich wahrscheinlich keine Zeit
>> für eine weitere Multiplikation und Division habe.
>
> Dann runde halt nich im Dezimalen, sondern im Binären mit Shift. Sieht
> zwar nicht so schön aus, erfüllt aber den Zweck...

Addiere jeweils 2^n Werte auf und schiebe die Summe n Bits nach rechts. 
Dann hast du eine Mittelwertbildung, ohne einen Divisionsbefehl 
ausführen zu müssen.

Wenn der Wertebereich nicht zu groß ist, kann man auch eine 
Lookup-Tabelle verwenden.

Karl Zeilhofer wrote:
> Dann runde halt nich im Dezimalen, sondern im Binären mit Shift. Sieht
> zwar nicht so schön aus, erfüllt aber den Zweck...

Dann erkläre doch mal, wie man das macht, im Binären mit Shift auf 100 
zu runden?

Stefan Ernst wrote:
> Karl Zeilhofer wrote:
>> Dann runde halt nich im Dezimalen, sondern im Binären mit Shift. Sieht
>> zwar nicht so schön aus, erfüllt aber den Zweck...
>
> Dann erkläre doch mal, wie man das macht, im Binären mit Shift auf *100*
> zu runden?

Stefan (Gast) hats bereit genau nach meiner Vorstellung vorgeführt.

Karl Zeilhofer wrote:

> Stefan (Gast) hats bereit genau nach meiner Vorstellung vorgeführt.

Und wo bitte wird da auf 100 gerundet?
Da wird auf 128 gerundet, so dass er als Ergebnis wieder "krumme" Werte 
hat.

Wenn man es eh an den PC sendet kann der doch auch das runden 
übernehmen...

Ja mir war auch klar das es mit schieben viel schneller geht.
Normalerweise würde ich es auch imer so machen.
Der Problemfall hier ist aber das ich in 100er Schritten runden muss.

Naja ich werde mal sehen ob ich das ganze noch etwas schneller 
hinbekomme.

Peter wrote:
>>Und wo bitte wird da auf 100 gerundet?
>>Da wird auf 128 gerundet, so dass er als Ergebnis wieder "krumme" Werte
>>hat.
> nur weil es im Decimalsystem nicht schön aussieht ist es doch im
> Binärsystem gut gerunden. Man muss halt etwas universeller Denken.

Und welchen Zweck erfüllt dann der im Binärsystem gerundete Wert? Gar 
keinen, denn eine korrekte Wertberuhigung (wie schon mehrfach erwähnt) 
macht man per Mittelwertbildung. Der einzige Grund für eine Rundung sind 
halt "schönere" Werte.

@ Tim T.:

Du hättest das mit dem Quark ruhig drin lassen können, stimmte ja.
Mein Blick auf den Code dort oben war doch etwas zu kurz.

Wie wärs damit:

1

unsigned Messwert();    // Gibt den nächsten Meßwert zurück

2

3

unsigned P10[] = { 10000, 1000, 100 };

4

long V = (long) Messwert();

5

unsigned R = 0;

6

7

for (int i = 0; i < arraysize(P10); i++) {

8

   do {

9

      V -= P10[i];

10

      R += P10[i];

11

   } while (V >= 0);

12

   V += P10[i];

13

   R -= P10[i];

14

}

15

16

if (V >= 50)

17

   R += 100;

18

19

// In R steht jetzt der auf 100 gerundete Wert

Obs letztlich kleiner/schneller ist, als Code mit Division weiß ich 
nicht... Das Prinzip läßt sich noch verfeinern.

ja, V und R. Bessere Variablen namen hätten es aber auch nicht sein 
können :P

Variablennamen schreibt man zusammen.

Ist richtig.

Version 2:

1

unsigned Messwert();    // Gibt den nächsten Meßwert zurück

2

3

unsigned P[] = { 51200, 25600, 12800, 6400, 3200, 1600, 800, 400, 200, 100 };

4

long V = (long) Messwert();

5

unsigned R = 0;

6

7

for (int i = 0; i < arraysize(P); i++) {

8

   if ((V -= P[i]) < 0)

9

      V += P[i];

10

   else

11

      R += P[i];

12

}

13

14

if (V >= 50)

15

   R += 100;

16

17

// In R steht jetzt der auf 100 gerundete Wert

Me ss wert mit mit doppel s geschrieben.... ;)

Nein.

Da Kn wrote:
> Damit
> die Werte nicht zu sehr schwanken würde ich gern in 100mV Schritten
> runden.
>
> Bsp.:
>
> Gemessener Wert:             Ausgegebener Wert:
> 24113mV                      24100mV
> 24159mV                      24200mV

Was meinst du mit "schwanken" deine ausgegebenen Werte haben ein 
größeres Delta als deine gemessenen Werte.

Was du willst ist quantisieren. Also Genauigkeit für die Ausgabe 
verschwenden.

Wenn du das Schwanken eindämmen willst, nimm die schon erwähnte Methode 
des Mittelwertes, dies geht sehr effektiv mit:

1

y = (x_alt + x_neu)>>1; /* (alt+neu)/2 */

Das mit deinen 100 ist natürlich ne ganz spezielle Anforderung. Wie auch 
schon erwähnt wurde kann man sowas mit 2^n Werten am effektivsten 
umsetzen.

ansonsten kommt in etwa sowas raus:

1

unsignend int a = 30154;

2

unsignend char rest;

3

4

rest = a % 100; /* an modulo in irgendeiner form kommt man nicht vorbei */

5

6

a = a  - rest;

7

8

if (rest >= 50){

9

  a = a + 100;

10

}else{

11

  /* nix */

12

}

GRUß ;-)