struct member Problem

[Fragender (Gast)]

Hi

In einem Interrupt TSC_Handler ich die getValue Funktion auf und 
schreibe sie in tscCurrentAcVal_1.
Das funktioniert auch.
Statt tscCurrentAcVal_1 möchte ich nun aber den Wert 
TSC_ONGOING_ACVAL.oLS1 übergeben.

uint16_t tscCurrentAcVal_1=0;
uint16_t observe;

typedef struct tscOnGoingAcVals{
uint16_t oLS1; 
uint32_t x_value;
}tscOnGoingAcVals_t;

#define TSC_ONGOING_ACVAL  (tscOnGoingAcVals_t) {0}

Im Interrupt TSC_Handler dann

tscCurrentAcVal_1 = (uint16_t) HAL_TSC_GroupGetValue(&htsc,TSC_LS1.groupIndex);
TSC_ONGOING_ACVAL.oLS1 = tscCurrentAcVal_1;
observe = TSC_ONGOING_ACVAL.oLS1;

uint32_t HAL_TSC_GroupGetValue(TSC_HandleTypeDef* htsc, uint32_t 
gx_index) gibt einen uint32_t aus.
Ich caste den Wert auf uint16_t, weil ich weiss, dass der jeweilige Wert 
nie grösser als ca. immer kleiner 10000 ist.

Wenn ich debugge und observe ansehe, ist der Wert immer 0, während 
tscCurrentAcVal sich immer ändert bzw. aktualisiert.

Ich verstehe nicht, warum ich den struct member mit dem Punktoperator 
nicht verändern kann. Wieder einmal sehe ich leider den Fehler nicht.

[Fragender (Gast)]

Fragender schrieb:
> Hi
>
> #define TSC_ONGOING_ACVAL  (tscOnGoingAcVals_t) {0}
>


sollte
#define TSC_ONGOING_ACVAL  (tscOnGoingAcVals_t) {0,0}
sein

[rµ (Gast)]

Was soll der Sinn von dem Makro sein? Da wird jedesmal eine neue anonyme 
struct mit 0 initialisiert und dann sofort wieder weggeworfen.

[rµ (Gast)]

anders gesagt: der compiler sieht folgendes:

tscCurrentAcVal_1 = (uint16_t) HAL_TSC_GroupGetValue(&htsc,TSC_LS1.groupIndex);
(tscOnGoingAcVals_t) {0,0}.oLS1 = tscCurrentAcVal_1;
observe = (tscOnGoingAcVals_t) {0,0}.oLS1;

wundert mich dass das überhaupt compiliert ;-)

[Fragender (Gast)]

rµ schrieb:
> anders gesagt: der compiler sieht folgendes:
>
> tscCurrentAcVal_1 = (uint16_t)
> HAL_TSC_GroupGetValue(&htsc,TSC_LS1.groupIndex);
> (tscOnGoingAcVals_t) {0,0}.oLS1 = tscCurrentAcVal_1;
> observe = (tscOnGoingAcVals_t) {0,0}.oLS1;
>
> wundert mich dass das überhaupt compiliert ;-)

Ja das haben in meinem vorherigen Post

Beitrag "Typenkonflikte in KeiluV5"

auch manche behauptet und es hat dann doch funktioniert. Entweder sind 
einige auf einem alten Stand was C angeht, aber ich habe es in meiner 
Ausbildung halt mal so gelernt, wobei ich jetzt nicht sagen möchte, dass 
ich C besser beherrsche als andere.

Ich habe das nun anders gelöst.

In einem h-file definiert

struct tscOGAcVal{
uint16_t oLS1; 
uint16_t x; 
};

Im main.c eine Variable vom Typ struct:

struct tscOGAcVal tscOnGoingAcValue;

und im Interrupt h-file

tscCurrentAcVal_1 = (uint16_t) HAL_TSC_GroupGetValue(&htsc, TSC_LS1.groupIndex);
tscOnGoingAcValue.oLS1 = tscCurrentAcVal_1;
observe = tscOnGoingAcValue.oLS1;

das funktioniert zwar, aber ich finde die globale struct Variable nicht 
schön..
Wie kann man das besser machen?
Bedingung ist, dass struct tscOGAcVal in einem h-file ist und die 
erstellte Variable vom Typ struct aber in einem anderen h-file genutzt 
wird.

[Markus F. (mfro)]

... ein wirklich hübsches Beispiel dafür, wie man sich selbst ins Knie 
schießen kann ;)

[Fragender (Gast)]

Fragender schrieb:
> rµ schrieb:

>
> Im main.c eine Variable vom Typ struct:struct tscOGAcVal
> tscOnGoingAcValue;
> und im Interrupt h-filetscCurrentAcVal_1 = (uint16_t)
> HAL_TSC_GroupGetValue(&htsc, TSC_LS1.groupIndex);
> tscOnGoingAcValue.oLS1 = tscCurrentAcVal_1;
> observe = tscOnGoingAcValue.oLS1;
> das funktioniert zwar, aber ich finde die globale struct Variable nicht
> schön..
> Wie kann man das besser machen?
> Bedingung ist, dass struct tscOGAcVal in einem h-file ist und die
> erstellte Variable vom Typ struct aber in einem anderen h-file genutzt
> wird.

Wenn ich das über eine Funktion löse, muss ich den Speicher im main() 
alloziieren und eine Funktion schreiben, die Teil von main.c ist und der 
Prototyp im main.h steht. Sehe ich das richtig?

[rµ (Gast)]

Nur zur Info, ich habe da keine Behauptungen aufgestellt. Ein 
vernünftiger Compiler mit vernünftigen Einstellungen spuckt bei so einer 
Zeile

(tscOnGoingAcVals_t) {0,0}.oLS1 = tscCurrentAcVal_1;

zumindest eine Warnung auf dass die ganze Angelegenheit ohne Effekt ist.

was spricht dagegen einfach

observe = (uint16_t) HAL_TSC_GroupGetValue(&htsc, TSC_LS1.groupIndex);

zu schreiben? aus dem kurzen Beispiel wird nicht klar wozu die struct 
gut ist bzw. wo sie verwendet wird.

[rµ (Gast)]

"Oberste Prinzipien Clarice. Simplifikation… lesen Sie bei Marc Aurel 
nach. Bei jedem einzelnen Ding die Frage, was ist es in sich selbst? Was 
ist seine Natur? Was soll er tun, dieser Interrupt-Handler, den Sie 
suchen?"

[Fragender (Gast)]

rµ schrieb:
> Nur zur Info, ich habe da keine Behauptungen aufgestellt. Ein
> vernünftiger Compiler mit vernünftigen Einstellungen spuckt bei so einer
> Zeile
> (tscOnGoingAcVals_t) {0,0}.oLS1 = tscCurrentAcVal_1;
>
> zumindest eine Warnung auf dass die ganze Angelegenheit ohne Effekt ist.
>
> was spricht dagegen einfachobserve = (uint16_t)
> HAL_TSC_GroupGetValue(&htsc, TSC_LS1.groupIndex);
> zu schreiben? aus dem kurzen Beispiel wird nicht klar wozu die struct
> gut ist bzw. wo sie verwendet wird.

die Idee von mir ist eigentlich, dass ich die meisten Konstanten und 
struct Variablen von einem generellen h-file ändern/anpassen kann, ohne 
tiefer in den Code zu gehen zu müssen und zusammengehörende Variablen 
sollten auch möglichst beieinander sein, also visuell wie auch 
codetechnisch was den Speicher betrifft. Deshalb möchte ich es so lösen. 
Ausserdem frische ich so altes, fast vergessenes, schultechnisches 
Wissen wieder auf.

Es tut richtig gut im Moment so auf die "Schnauze" zu fallen. Die 
Lernkurve ist da enorm.

Das Ganze ist keine Hausaufgabe, ich mache das für mich.

Ich wäre euch also dankbar, wenn ihr mir diesbezüglich weiterhelfen und 
mir also die Frage beantworten könntet.

[rµ (Gast)]

Fragender schrieb:
> Ich wäre euch also dankbar, wenn ihr mir diesbezüglich weiterhelfen und
> mir also die Frage beantworten könntet.

Die Antwort auf

Fragender schrieb:
> Wenn ich das über eine Funktion löse, muss ich den Speicher im main()
> alloziieren und eine Funktion schreiben, die Teil von main.c ist und der
> Prototyp im main.h steht. Sehe ich das richtig?

ist eindeutig "nein", allerdings ist dabei nicht klar, was mit einer 
Funktion gelöst werden soll.

In diesem Sinne haben ich leider keine beantwortbare Frage gefunden. Ich 
vermute Knopf im Hirn, darum würde ich vorschlagen nochmal nachzudenken 
was eigentlich konkret passieren soll.