C - Einer Funktion, eine Adresse eines Struktur Members übergeben?!

[Jan H. (janiiix3)]

Hallo,

ich möchte gerne diese Funktion ein bisschen Variable gestalten.
Nun meine Frage. Bei meinem ATXMega gibt es beim Timer0 4 div. Compare 
Register ( CCA - CCD )

Hier die Struktur

/* 16-bit Timer/Counter 0 */
typedef struct TC0_struct
{
    register8_t CTRLA;  /* Control  Register A */
    register8_t CTRLB;  /* Control Register B */
    register8_t CTRLC;  /* Control register C */
    register8_t CTRLD;  /* Control Register D */
    register8_t CTRLE;  /* Control Register E */
    register8_t reserved_0x05;
    register8_t INTCTRLA;  /* Interrupt Control Register A */
    register8_t INTCTRLB;  /* Interrupt Control Register B */
    register8_t CTRLFCLR;  /* Control Register F Clear */
    register8_t CTRLFSET;  /* Control Register F Set */
    register8_t CTRLGCLR;  /* Control Register G Clear */
    register8_t CTRLGSET;  /* Control Register G Set */
    register8_t INTFLAGS;  /* Interrupt Flag Register */
    register8_t reserved_0x0D;
    register8_t reserved_0x0E;
    register8_t TEMP;  /* Temporary Register For 16-bit Access */
    register8_t reserved_0x10;
    register8_t reserved_0x11;
    register8_t reserved_0x12;
    register8_t reserved_0x13;
    register8_t reserved_0x14;
    register8_t reserved_0x15;
    register8_t reserved_0x16;
    register8_t reserved_0x17;
    register8_t reserved_0x18;
    register8_t reserved_0x19;
    register8_t reserved_0x1A;
    register8_t reserved_0x1B;
    register8_t reserved_0x1C;
    register8_t reserved_0x1D;
    register8_t reserved_0x1E;
    register8_t reserved_0x1F;
    _WORDREGISTER(CNT);  /* Count */
    register8_t reserved_0x22;
    register8_t reserved_0x23;
    register8_t reserved_0x24;
    register8_t reserved_0x25;
    _WORDREGISTER(PER);  /* Period */
    _WORDREGISTER(CCA);  /* Compare or Capture A */
    _WORDREGISTER(CCB);  /* Compare or Capture B */
    _WORDREGISTER(CCC);  /* Compare or Capture C */
    _WORDREGISTER(CCD);  /* Compare or Capture D */
    register8_t reserved_0x30;
    register8_t reserved_0x31;
    register8_t reserved_0x32;
    register8_t reserved_0x33;
    register8_t reserved_0x34;
    register8_t reserved_0x35;
    _WORDREGISTER(PERBUF);  /* Period Buffer */
    _WORDREGISTER(CCABUF);  /* Compare Or Capture A Buffer */
    _WORDREGISTER(CCBBUF);  /* Compare Or Capture B Buffer */
    _WORDREGISTER(CCCBUF);  /* Compare Or Capture C Buffer */
    _WORDREGISTER(CCDBUF);  /* Compare Or Capture D Buffer */
} TC0_t;

void timerSetCompareValue  ( TC0_t *tim0 , TC1_t *tim1 , register16_t ccx , uint16_t val )  
{
  if ( tim0 != NULL )
  {
    (( tim0->CCA ) + ccx ) = 0; // haut wohl so nicht hin..
  }
}

Kann ich der Funktion dann die Adresse des zu beschreibenden CCx 
Registers übergeben?

[Niklas G. (erlkoenig)]

Mach doch statt CCA-CCD ein Array "CCn[4]" und nutze "ccx" als Index.

PS: Der Bezeichner _WORDREGISTER in C der Standard-Bibliothek bzw. 
Compiler vorenthalten und nicht für User-Code erlaubt, da er mit 
Unterstrich+Großbuchstabe beginnt.

[Klaus Dieter D. (Gast)]

Niklas G. schrieb:
> Mach doch statt CCA-CCD ein Array "CCn[4]" und nutze "ccx" als
> Index.
>
> PS: Der Bezeichner _WORDREGISTER in C der Standard-Bibliothek bzw.
> Compiler vorenthalten und nicht für User-Code erlaubt, da er mit
> Unterstrich+Großbuchstabe beginnt.

Okay.. aber wie komme ich dann z.b auf CCD?

[Klaus Dieter D. (Gast)]

Also mich interessiert das auch mal..

[Niklas Gürtler (Gast)]

_WORDREGISTER(CCn [4]);  /* Compare or Capture A */

tim0->CCn [ccx]

Je nachdem wie _WORDREGISTER definiert ist funktioniert das ggf nicht

[Jan H. (janiiix3)]

Kann dir nicht ganz folgen...
Warst du so gut und könntest nen Pseudocode posten?

[Rolf M. (rmagnus)]

Jan H. schrieb:
> (( tim0->CCA ) + ccx ) = 0; // haut wohl so nicht hin..

Das ergibt ja auch keinen Sinn. Verkürzt geschrieben wäre das ja das 
gleiche wie:

a + b = 0;

Auf was sollen da a und b gesetzt werden?
Die Klammern haben übrigens keinerlei Effekt.

Ich vermute, was du eigentlich meintest, wäre sowas:

> (&tim0->CCA)[ccx] = 0;

Das ist aber eher ziemlich hässlich.
Du versuchst, Elemente einer Struktur so anzusprechen, als seien sie 
Elemente eines Arrays. Deshalb der Vorschlag von Niklas Gürtler, diese 
gleich als Array anzulegen.

[Jan H. (janiiix3)]

Warum?
Sollte ich am besten für jeden Compare Match eine eigene Funktion 
schreiben um einen Wert zu setzen? Das soll später mal eine Timer 
Bibliothek werden, deshalb würde ich es gerne so machen wollen

[Rolf M. (rmagnus)]

Jan H. schrieb:
> Warum?

Warum was?

> Sollte ich am besten für jeden Compare Match eine eigene Funktion
> schreiben um einen Wert zu setzen?

Nein, du sollst ein Array definieren. Und am besten ein gutes C-Buch 
kaufen und durcharbeiten. Ich habe den Eindruck, du hast keine Ahnung, 
wovon wir sprechen, obwohl das doch sehr grundlegende Dinge sind.

[A. S. (Gast)]

offsetof()?

[Helmut S. (helmuts)]

Wie wäre es damit:
https://www.programiz.com/c-programming/c-structure-function

[Jan H. (janiiix3)]

Rolf M. schrieb:
> Ich vermute, was du eigentlich meintest, wäre sowas:> (&tim0->CCA)[ccx]
> = 0;

Danke! Das hilft mir weiter ;)

[A. H. (ah8)]

Rein technisch kannst Du den Offset eines Strukturelementes mit 
folgendem Ausdruck gewinnen:

(unsigned long) &((struct /*Structurname*/ *)0)->/*Elementname*/

also zum Beispiel:

struct X
{
        int     a;
        double  b;
        char    *c;
};

unsigned long offset_a = (unsigned long) &((struct X*)0)->a;
unsigned long offset_b = (unsigned long) &((struct X*)0)->b;
unsigned long offset_c = (unsigned long) &((struct X*)0)->c;

Ja, das funktioniert wirklich, da der Null-Pointer nie dereferenziert 
wird, er dient nur als Basis für die Adressrechnung. Diesen – oder jeden 
anderen Offset – kannst Du dann verwenden, um die Adresse des Elements 
in einer Struktur zu errechnen:

struct X x = { 5, 3.141, "hello world" };

unsigned long addr_x = (unsigned long) &x;
int    *addr_a = (int*)(addr_x + offset_a);
double *addr_b = (double*)(addr_x + offset_b);
char*  *addr_c = (char**)(addr_x + offset_c);

Das Casten der Adresse von X auf unsigned long ist notwendig, da Du 
mit den Binärwerten der Adresse rechnen willst. Dagegen wäre

&x + offset

äquvivalent zu

(struct X*) ((unsigned long) &x)+offset*sizeof(struct X))

berechnet also die Adresse einer Struktur mit gegebenen Offset in einem 
Array von Strukturen.

Vollständig sieht das dann so aus:

#include <stdio.h>

struct X
{
        int     a;
        double  b;
        char    *c;
};

unsigned long offset_a = (unsigned long) &((struct X*)0)->a;
unsigned long offset_b = (unsigned long) &((struct X*)0)->b;
unsigned long offset_c = (unsigned long) &((struct X*)0)->c;

int main()
{
        struct X x = { 5, 3.141, "hello world" };

        unsigned long addr_x   = (unsigned long) &x;
        int    *addr_a = (int*)(addr_x + offset_a);
        double *addr_b = (double*)(addr_x + offset_b);
        char*  *addr_c = (char**)(addr_x + offset_c);
  
        printf("%i\t%lf\t%s\n", x.a, x.b, x.c);
        printf("%lu\t%lu\t%u\n", offset_a, offset_b, offset_c);
        printf("%i\t%lf\t%s\n", *addr_a, *addr_b, *addr_c);
}

$ structOffset
5       3.141000        hello world
0       4       12
5       3.141000        hello world

Der Linux Kernel verwendet diese Technik, um auf die Linkelemente 
verketteter Listen in Strukturen zuzugreifen. Ob das schön ist, sei 
einmal dahin gestellt.


PS: Soweit ich mich erinnere ist unsigned long auf jeder Architektur 
garantiert groß genug, um einen Pointer aufzunehmen. Da bin ich mir aber 
nicht ganz sicher, im Zweifel müsste man das bitte nochmal im Standard 
nachlesen. Weiß das vielleicht jemand aus dem Kopf?

[A. H. (ah8)]

Jan H. schrieb:
> Rolf M. schrieb:
>> Ich vermute, was du eigentlich meintest, wäre sowas:> (&tim0->CCA)[ccx]
>> = 0;
>
> Danke! Das hilft mir weiter ;)

Das kann und wird auch in den meisten Fällen so funktionieren, ist aber 
nicht wirklich portabel. Der Compiler darf zwischen den Elementen einer 
Struktur Padding-Bytes einfügen, um sie an den physischen 
Speichergrenzen auszurichten und so einen schnelleren Zugriff zu 
ermöglichen. Zwischen Elementen eines Arrays gibt es Padding auf keinen 
Fall. Abhängig von Compiler und Architektur kann die Pointer-Arithmetik 
in diesem Fall also falsch rechnen, es sei denn, die Struktur wurde 
explizit als packed definiert, zum Beispiel:

struct TC0_struct
{
  ...
} __attribute((packed))__;

[Jan H. (janiiix3)]

Okay. Das ist mir neu. Danke!

[Rolf M. (rmagnus)]

A. H. schrieb:
> Ja, das funktioniert wirklich, da der Null-Pointer nie dereferenziert
> wird, er dient nur als Basis für die Adressrechnung.

Wird in der Praxis wohl meistens gehen, aber offiziell ist es nicht 
erlaubt.  Der offizielle Weg ist die Benutzung des Makros offsetof().

[Jan H. (janiiix3)]

Rolf M. schrieb:
> A. H. schrieb:
> Ja, das funktioniert wirklich, da der Null-Pointer nie dereferenziert
> wird, er dient nur als Basis für die Adressrechnung.
>
> Wird in der Praxis wohl meistens gehen, aber offiziell ist es nicht
> erlaubt.  Der offizielle Weg ist die Benutzung des Makros offsetof().

Wie sieht das denn dann mit der Funktion aus?

[Rolf M. (rmagnus)]

Statt z.B.

A. H. schrieb:

> unsigned long offset_a = (unsigned long) &((struct X*)0)->a;

wäre besser:

size_t offset_a = offsetof(struct X, a);

und man bräuchte ein

#include <stddef.h>

Auch das würde ich so nicht machen:

A. H. schrieb:
> unsigned long addr_x   = (unsigned long) &x;
> int    *addr_a = (int*)(addr_x + offset_a);

Warum nicht einfach mit Zeigern arbeiten, wenn man mit Adressen 
hantiert?  Wenn schon ein Integer, dann intptr_t. Der ist garantiert 
groß genug, um einen Zeiger aufzunehmen.
Ich würd's aber so machen:

char* addr_x   = (char*)&x;
int    *addr_a = (int*)(addr_x + offset_a);

A. H. schrieb:
> PS: Soweit ich mich erinnere ist unsigned long auf jeder Architektur
> garantiert groß genug, um einen Pointer aufzunehmen.

Nein. Der ist auf so genannten IL32P64-Architekturen zu klein. Eine 
davon wäre z.B. die 64-Bit-Version von Windows.
Dafür ist unsigned long auf kleinen 8-Bittern oft eher unnötig groß, da 
er mindesten 32 Bit breit ist.

[Jan H. (janiiix3)]

>

>> unsigned long offset_a = (unsigned long) &((struct X*)0)->a;
>

>
> wäre besser:
>
>

> size_t offset_a = offsetof(struct X, a);
>

Doofe Frage.. Jetzt habe ich zwar den Offset aber jedoch nicht die 
Adresse im an den der Position mit dem Offset zu schreiben?

[mh (Gast)]

A. H. schrieb:
> Rein technisch kannst Du den Offset eines Strukturelementes mit
> folgendem Ausdruck gewinnen:
> (unsigned long) &((struct /*Structurname*/ *)0)->/*Elementname*/
Warum sollte man das machen, wenn es offsetof gibt?


A. H. schrieb:
> PS: Soweit ich mich erinnere ist unsigned long auf jeder Architektur
> garantiert groß genug, um einen Pointer aufzunehmen. Da bin ich mir aber
> nicht ganz sicher, im Zweifel müsste man das bitte nochmal im Standard
> nachlesen. Weiß das vielleicht jemand aus dem Kopf?
Nein, es ist nicht garantiert, dass unsigned long groß genug ist.