Cast richtig?

[I. L. (Gast)]

Moin,

ich frage mcch ob dieser Cast hier richtig durchgeführt ist:

Leistung.soll = ((Spannung.ist - 350) * (float) 37.5) + 1000;

Alle Variable sind uint16_t!

und

t = (unsigned long) Strom.ist * Spannung.ist;

wenn t ein uint32_t ist, ist dann der Cast noch nötig?



Gruß Knut

[Lehrmann M. (ubimbo)]

I. L. schrieb:
> Leistung.soll = ((Spannung.ist - 350) * (float) 37.5) + 1000;

Wenn das C ist, dann sollte das eigentlich nicht kompiliert werden ...
Variablennamen: A-Z und a-z und 0-9 und _

[Rufus Τ. F. (rufus)]

I. L. schrieb:
> Leistung.soll = ((Spannung.ist - 350) * (float) 37.5) + 1000;

Eine float-Konstante (37.5) muss nicht nach float gecastet werden.

[I. L. (Gast)]

Lehrmann Michael schrieb:
> Wenn das C ist, dann sollte das eigentlich nicht kompiliert werden ...
> Variablennamen: A-Z und a-z und 0-9 und _

Ist ein Struct keine Variable? Es ist C

EDIT: Natürich nicht, aber jedes Mitglied eines Structes ist eine 
Variable!

Gruß Knut

[Bernd B. (bernddasbrot)]

Leistung.soll = ( ((float)Spannung.ist - 350.) * 37.5) + 1000.;

sollte besser funktionieren, dann gehen die Nachkommastellen erst ganz 
zum Schluss verloren.

[derdas (Gast)]

Der Ursprungs-cast ist völlig überflüssig. Durch die type-promotion ist 
das Produkt eines uint16_t und eines float wieder ein float. Der 
uint16_t Parmeter wird dabei zunächst implizit in ein float umgewandelt. 
Also haben wir bei diesem Ausdruck:

Leistung.soll = ((Spannung.ist - 350) * 37.5) + 1000;

eine Integer Subtraktion, eine float Multiplikation, und eine float 
Addition. Anschließend wir alles wieder implizit nach uint16 gecastet. 
Der einzige Unterschied von

Leistung.soll = ( ((float)Spannung.ist - 350.) * 37.5) + 1000.;

ist also das auch die Subtraktion also float durchgeführt wird.

Float operationen sind auf Mikrocontrollern aber recht teuer. Ich würde 
(sofern Deine 75-fache Spannungsdifferenz  kleiner als 64535V ist, wg. 
des Überlaufes) das Ganze hier mittels Integern berechnen. Und um sicher 
zu gehen dass keine signed integer verwendet werden besser alle 
constanten unsigned machen:

Leistung.soll = ((Spannung.ist - 350U) * 75U) / 2U + 1000U;

Und wenn der Compiler nicht auf den Kopf gefallen ist macht er daraus:

Leistung.soll = ((Spannung.ist - 350U) * 75U) >> 1U + 1000U;

was das gleiche ist.

[I. L. (Gast)]

derdas schrieb:
> Und wenn der Compiler nicht auf den Kopf gefallen ist macht er daraus:

Ist der GCC auf den Kopf gefallen?

[Karl H. (kbuchegg)]

Nein.
Dein Compiler kennt diese Tricks alle. Und auch noch welche, von denen 
du noch nie gehört hast.

Das haben wir schon gerne. Erst alles in float rechnen wollen und sich 
dann Sorgen wegen einer läppischen Division durch 2 machen. :-)

[derdas (Gast)]

Ah, hatte den zweiten Teil übersehen. Da muss sehr wohl gecasted werden 
!
Der "Zieldatentyp" spielt nämlich bei den ganzen Betrachtungen keine 
Rolle, d.h.:

t = Strom.ist * Spannung.ist;

würde erst eine uint16_t Multiplikation (mit entsprechenden Überlauf) 
durchführen, und für die Zuweisung auf uint32_t wandeln. Wenn also das 
Produkt von U ind I größer als 65535 werden kann, dann besser casten, 
sonst eher nicht !

[I. L. (Gast)]

Karl heinz Buchegger schrieb:
> Dein Compiler kennt diese Tricks alle. Und auch noch welche, von denen
> du noch nie gehört hast.

Na hoffentlich ;-)

Kurze Frage nochmal zum Compiler, wenn ich Eclipse nutzen möchte, und 
das AVR Plugin reinhaue, ist das trotzdem noch der GCC Compiler?

derdas schrieb:
> Der "Zieldatentyp" spielt nämlich bei den ganzen Betrachtungen keine
> Rolle

Das is mal ne Aussage!

Dankeschön!

Gruß Knut

[Achim M. (minifloat)]

I. L. schrieb:
> wenn ich Eclipse nutzen möchte, und
> das AVR Plugin reinhaue, ist das trotzdem noch der GCC Compiler

Yes, Sir.
mfg mf

[I. L. (Gast)]

Aha. Kann man nicht irgendwie beim AVR Studio dem Programm sagen das es 
doch bitte die Klammerpaare markieren soll wie beim Programmers Notepad 
2?

Ansonsten ist das doch schon ganz hinnehmbar. Eclipse is natürlich 
cooler, aber leider auch umständlicher mit AVRs.



Gruß Knut