Skalenanzeige: runden von Variablen

[Michael (Gast)]

Hallo zusammen,

ich weiß nicht weiter, bei der Dartellung eines Sensorwertes, der anhand 
einer einfachen Skalenanzeige eines DOG-Displays visualisiert werden 
soll.

Der Sensorwert liegt als float-Variable (vereinfacht) zwischen 0 und 60.
Ich werwende die zweite Zeile des Displays an Skalenanzeige. Die Zeile 
hat 16 Elemente. 60/16 ergibt 3,75. Ich würde gerne bei Werten bis 3,75 
das erste Element ein Zeichen angeben lassen, bei Werten z.Bsp. 
(3x3,75)bis 11,25
die Skala bis zum dritten Zeichen etwas anzeigen lassen usw..
Wie setzte ich das programmiertechnisch am einfachsten um ?

Sensorwert 3,5:
[|               ]
Sensorwert 35
[|||||||||       ]

Wie würdet ihr das machen ? Ich habe im Forum nur leider Artikel zum 
runden von Nachkommazahlen etc. gefunden.
Hat da jmd. ein Stichwort ?

Danke,
Michael

[LostInMusic (Gast)]

Wie wäre es mit "round(x/3.75)" oder dazu äquivalent "trunc(x/3.75 + 
0.5)"?

Die genaue Funktion hängt davon ab, ob Du z. B. bei einem Wert von 1.0 
schon ein Segment on haben willst, oder nicht. Oder wann genau alle 
Segmente on sein sollen.

[wendelsberg (Gast)]

Pseudo (perl-like):

wert_anz = wert / 16;
string=anz = "";
for(i=1;i<=wert_anz;i++){string_anz = string_anz + "|";};
print string_anz;

wendelsberg

[Wolfgang (Gast)]

Michael schrieb:
> Der Sensorwert liegt als float-Variable (vereinfacht) zwischen 0 und 60.
> Ich werwende die zweite Zeile des Displays an Skalenanzeige. Die Zeile
> hat 16 Elemente. 60/16 ergibt 3,75.

Dann verabschiedest du dich erstmal von dem Datentyp float. 
Multipliziere deine Werte mit 4 und du bist irgendwelche 
Nachkommastellen für die Umschaltpunkte los. Und dann solltest du 
erstmal festlegen, wo genau umgeschaltet werden soll (s.o.)

[wendelsberg (Gast)]

wendelsberg schrieb:
> string=anz = "";

Grrr.

die Zeile muss natuerlich heissen:

string_anz = "";

[wendelsberg (Gast)]

Noch eine Idee:

Du kannst davor auch noch setzen:

Wert = Wert * 1.067;

Damit wird dann Dein Maximalwert 60 zu besser berechenbaren 64 und 
jeweils 4 entsprechen einem Balken.

wendelsberg

[Wolfgang (Gast)]

wendelsberg schrieb:
> Du kannst davor auch noch setzen:
>
> Wert = Wert * 1.067;

Da ist es doch wesentlich günstiger mit 17/64 zu rechnen. Die 
Genauigkeit von 0,4% sollte allemal ausreichen.

Mit dem Faktor 1.067 wird man den ganzen Float-Overhead nicht los. Aber 
manche µC langweilen sich leicht zu tode und da ist es gut, wenn man sie 
mit ein bisschen Float-Rechnerei in Bewegung hält. Für nicht genutzten 
Flash Speicher gibt es sowie so kein Geld zurück.</ironie>

[wendelsberg (Gast)]

Wolfgang schrieb:
> Da ist es doch wesentlich günstiger mit 17/64 zu rechnen. Die
> Genauigkeit von 0,4% sollte allemal ausreichen.

Man koennte natuerlich diesen Faktor auch gleich in die vorgelagerte 
Floatberechnung einfliessen lassen, so dass eben nicht Werte von 0 bis 
60, sondern Werte von 0 bis 64 ankommen, bei denen koennte man dann 
einfach mit dem ganzzahligen Teil weiterrechnen.

> Mit dem Faktor 1.067 wird man den ganzen Float-Overhead nicht los. Aber
> manche µC langweilen sich leicht zu tode und da ist es gut, wenn man sie
> mit ein bisschen Float-Rechnerei in Bewegung hält. Für nicht genutzten
> Flash Speicher gibt es sowie so kein Geld zurück.</ironie>

Nein, das hatte ich schon so gedacht, dass die 0-60 zuerst zu 0-64 
werden und man dann ganzzahlig weiterarbeiten kann.
Man will den uC ja auch nicht zu sehr stressen ;-:

Aufpassen muss man dann aber, was bei 4/64 wirklich herauskommt, dort 
muss man unter Umstaenden noch eine Korrektur einbauen.

wendelsberg

[Joe F. (easylife)]

Wenn du Nenner und Teiler mal 4 nimmst, geht es als reine 
Integer-Rechnung.

also

out = in * 4 / 15;

passt sogar gerade noch in eine 8-bit variable (60*4=240)

wenn's ganz toll werden soll:

out = (in << 2) / 15;

[Uwe K. (ukhl)]

Wenn das BYTE immer abrundet:

out = ((in << 2) + 14) / 15;

[Joe F. (easylife)]

Ui... Glück gehabt, 254 passt auch gerade noch rein ;-)