multiplikation Mal Kommazahl

danke der Antwort
reicht es wenn das einfach in meinem Prg. schreibe?

Sofern du aufm AVR bist, würd ich dir raten, die Messwerte kräftig 
aufzublasen (alles *1000 oder noch mehr) und dann als Integer 
weiterzurechnen.

Vielleicht hätte auch schon das Ersetzen des Kommas durch einen Punkt 
zum erwarteten Ergebnis geführt.

Gruß Matthias

ich benutze einen Motorola mit einer 10Bit Auflösung des AD
heisst das ich schreibe einfach die Formel:
Xsoll= ((1.7692*1023)*Xist+(555,2*1023))/1023; ?

>Vielleicht hätte auch schon das Ersetzen des Kommas durch einen Punkt
>zum erwarteten Ergebnis geführt.

nein, mein Compiler versteht das Komma und kein Punkt als das 
Kommazeichen

> nein, mein Compiler versteht das Komma und kein Punkt als das
> Kommazeichen

Ist der von Microsoft?
Und selbst da kann ich mir das nicht vorstellen.
Schließlich gibt es einen Sprachstandard für C,
der sicherlich schon älter ist als Du.
(Bitte verzeih die Hetze).

bitte kurz mal auf meinem Code schauen:

    val_x = current_value_x;
    val_y = current_value_y;
    //Gleichchung fuer Linearisierung
    Lin_current_value_x = (1,7692*1023)*val_x;


    Lin_current_value_y = 1,7692*val_y ;
Es wurde so kompiliert und zum emulator geschickt!
kann jemand dies vielleicht erklären?
Danke für die nette Hilfe!

Aber bitte mit 1024 multiplizieren, das läuft dann auf einen Shift 
hinaus.


Man muss einfach sein Denken ein wenig umstellen auf binär.

So wie Benedikt oder so ähnlich würde ich es auch machen.


@Benedikt:
Xsoll= ((1.769265536*65536L)*Xist+(555,2*65536L))/65536L;
Hast Du die Konstante 1.76 vergenauert um 5 Stellen?  ;-)


@Abderrahim
Vielleicht könntest Du uns mal verraten, welche Umgebung Du verwendest?

>???

Originalpost:
Xsoll= 1,7692*Xist+555,2;
         ^^^^
> Benedikt K. (benedikt)
>Xsoll= ((1.769265536*65536L)*Xist+(555,2*65536L))/65536L;
            ^^^^^^^^^
                ^^^^^

ich benutze einen Freescale CodeWarrior
Wieso soll ich mal 65536 multipl.?
Ich habe bloß eine 10Bit Auflösung keine 16.
Was meinst du mit :
> > Hast Du die Konstante 1.76 vergenauert um 5 Stellen?

habe das probiert:
    Lin_current_value_x = (17692*val_x)/10000;
    Lin_current_value_x = (word)((1,7692*1000)*val_x)/1000;
bekomme das Gleiche Ergebnis!
Mein "Val_x" ist 407, also der "Lin_current_value_x" sollte auf ungefähr
2 langen, bekomme aber 3 wackelnde Werte: 3..30..54
bin total verwirrt!
Kann jemand helfen?

Wenn du mit C arbeitest, kannstu dich aufn Kopf stellen:

1

    Lin_current_value_x = (word)((1,7692*1000)*val_x)/1000;

ist definitiv Käse! Das hat es noch nie im C-Standard gegeben und das 
wird es auch nie geben.

Syntaktisch ist das korrekt, das nennt man KOMMAOPERATOR; gerechnet 
wird aber anders:

1

((1,7692*1000)*val_x)/1000

2

/* ist gleich */

3

(1*val_x)/1000

>17692*val_x)
>"Val_x" ist 407
=> 17692 * 407 = 7'200'644 = (uint16) 57219

(uint16) (17692*407) / 10000  = (57219/10000) = 5
...


Poste mal die Deklarationen der Variablen

> Poste mal die Deklarationen der Variablen
word      current_value_x;
word      current_value_y;
word      Lin_current_value_x;
word      Lin_current_value_y;
word      Offset=111;
word      val_x;
word      val_y;

> => 17692 * 407 = 7'200'644 = (uint16) 57219
was heisst hier (7'200'644)?
> (uint16) (17692*407) / 10000  = (57219/10000) = 5
 Leute irgendwie folge ich euch euch nicht mehr,
bin ganz Anfänger im Ding, und da sehe schon solche Komentare:
>Wenn du mit C arbeitest, kannstu dich aufn Kopf stellen:
Das verletzt!

Swen Pauli hats geschrieben, Kommaoperator.
Ersetz das Komma durch einen Dezimalpunkt,
und Deine Probleme sollten verschwinden...

nein leider nicht,
wenn ich es tue zeigt mir der Compiler fehler,
und einiges über data Verlust

Ja in diese Richtung,
deshalb habe ich ein (word) benutzt:
Lin_current_value_x = (word)((1,7692*1000)*val_x)/1000;
oder soll es anders formuliert sein?

Noch eins: Du könntest versuchsweise die Zielvariable
als float deklarieren anstatt word.

Hallo,
bitte mal die Links schauen!

hier der C-Code

mit der Float nimmt er es auch nicht an!
Leute bin euch wircklich sehr dankbar,
ich melde mich nochmal heute, muß jetzt verlassen,
wünsche euch schöne Nacht und schönen Feiertag !

Autor: Matthias Lipinsky (lippy)
Datum: 21.05.2008 20:38
wollte sagen, dass durch das Ergebnis der Multiplikation 17692 * 407 = 
7'200'644  nicht in eine word-Variable passt und deswegen nur noch die 
16 unteren Bits (uint16) 57219  drinstehen werden.

Das ist einer der häufigsten Fehler beim Programmieren.

Du musst auf (long int) casten  oder  eine temporäre long int-Variable 
für das Ergebnis definieren.

    Lin_current_value_x = (long int)(17692*val_x/10000);
oder
    Lin_current_value_x = 17692L * val_x / 10000;

Besser, da 10000 für einen µC eine krumme Zahl (0x2710) ist:
unsigned int Lin_current_value_x;
    Lin_current_value_x = (1.7692*1024L * val_x + 555.2*1024L) / 1024;
oder
    Lin_current_value_x = (1.7692*32768L * val_x + 555.2*32768L) / 
32768;


Sobald der Compiler einmal ein L sieht, führt er alle Berechnungen 
des Ausdruckes  als long aus.

@Benedikt:
Xsoll= ((1.7692*1023)*Xist+(555,2*1023))/1023;
Ja, multiplizieren kann er schon beim Compilen, aber dividieren muss er 
zur Runtime.

eins hab ich nicht geachtet, und  vielleicht ist das der Grund warum ich 
die Fehler bekam,
"val_x" ist eine word-Variable.
Kann sein dass der Compiler keine words mit floats multiplizieren kann?

Hi Thomas,
wie gesagt meine Variablen sollen words oder dwords sein, damit ich sie 
später von einer Funktion aufrufen kann:
SetGet(signed_word Xsoll,signed_word Ysoll,dword *R,word *W)