Warum geht GCC Extern hier nicht?

[Simon (Gast)]

//main.c
static const struct _module_config
{
    uint16_t     passkey[8];
    uint8_t      mac[6];        // 6b  Mac Address of Module
} module_config = { {0} , {0xAA,0xBB,0xCC,0x11,0x22,0x33}   };


//xx.c
extern _module_config module_config;

put(&module_config.mac[0],0);

error: 'module_config' undeclared (first use in this function)

Wieso geht extern hier nicht?

[nicht"Gast" (Gast)]

Moin,

vermutlich fehlt da ein struct davor.

extern struct _module_config module_config;

[nicht"Gast" (Gast)]

und wieder...

das static muss natürlich auch weg, wenn du das struct in anderen 
Dateien benutzen willst.

[Planlos (Gast)]

Du musst die Typ-Definition deines Structs in ein Header-File auslagern.
in das kann dann auch die "extern"-Zeile.

in main.c dann die Variable anlegen und initialisieren, aus xx.c kannst 
du dann darauf zugreifen.

(in xx.c muss auch bekannt sein, wie die struct intern aussieht, also 
z.B. dass es darin ein Member "mac" gibt)

[Rolf M. (rmagnus)]

Simon schrieb:
> //main.c
> static const struct _module_config

static heißt, dass der Namne von außen nicht sichtbar ist. Warum hast du 
das da hingeschrieben?

> {
>     uint16_t     passkey[8];
>     uint8_t      mac[6];        // 6b  Mac Address of Module
> } module_config = { {0} , {0xAA,0xBB,0xCC,0x11,0x22,0x33}   };
>
> //xx.c
> extern _module_config module_config;

Hier versuchst du, von außen den Namen zu benutzen, den du oben explizit 
gegen die Nutzung von außen gesperrt hast.
Das ist aber nicht der Grund für die Fehlermeldung. Wie nicht"Gast" oben 
schon geschrieben hat, heißt der Typ nicht _module_config, sondern 
struct _module_config, und der Typ muss natürlich in xx.c auch bekannt 
sein.

[Simon (Gast)]

config.h

extern const struct _module_config
{
    uint16_t     passkey[8];
    uint8_t      mac[6];        // 6b  Mac Address of Module
} module_config;

alle_anderen.c

const struct _module_config module_config = { {0} , {0xAA,0xBB,0xCC,0x11,0x22,0x33}   };

Scheint so zu gehen

[Rolf M. (rmagnus)]

Ja, sollte so passen, sofern du mit "alle_anderen.c" eine einzelne Datei 
und nicht alle anderen C-Files meinst. Die unterste Zeile darf nur in 
genau einer Datei stehen.

[Simon (Gast)]

ja genau. vielen Dank!

[Mikro 7. (mikro77)]

Zwei kleine Hinweise...

Simon schrieb:
>...

Wenn man das "ausführlich" schreibt, ist das also:

struct _module_config
{
  uint16_t passkey[8];
   uint8_t     mac[6];
} ;

extern const struct _module_config module_config ;

Bezeichner "sollten" in C allerdings nicht mit einem Unterstrich 
beginnen. (Um potentielle Konflikte mit vom Compiler definierten Namen 
zu vermeiden.)

nicht"Gast" schrieb:
> und wieder...
>
> das static muss natürlich auch weg, wenn du das struct in anderen
> Dateien benutzen willst.

Manchmal kann es sinnvoll sein (static const) Variablen im Header zu 
instantiieren. Man erhält in jedem Object File eine (identische) 
Instanz. Durch das "static" gibt es keine Namenskonflikte. Man könnte 
also durchaus in den Header schreiben:

static const struct _module_config = {{0},{0xAA,0xBB,0xCC,0x11,0x22,0x33}};

Edit: Wie im Eingangsposting gezeigt. Auf das "extern" verzichtet man 
dann. Wenn man das extern richtig deklariert stört es aber auch nicht.

[Kaj (Gast)]

Bau dir doch eine Schnittstelle, dann brauchst du auch kein extern. Das 
könnte dann so, oder so ähnlich aussehen:

/*  ==================================================  */
/*  Modul A Header: mod_a.h                             */

#include <stdint.h>

#define PASSKEY_LEN     16
#define MAC_LEN         6


struct mod_conf_t
{
    uint16_t passkey[ PASSKEY_LEN ];
    uint8_t  mac[ MAC_LEN ];
};


void get_passkey(uint16_t *buff);
void get_mac(uint8_t* buff);

void set_passkey(uint16_t value, uint8_t index);
void set_mac(uint8_t value, uint8_t index);


/*  ==================================================  */
/*  Modul A: mod_a.c                                    */

#include <string.h>

#include "mod_a.h"


static struct mod_conf_t mein_globales_struct = {
                                {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15},
                                {0,1,2,3,4,5}

};


void get_passkey(uint16_t *buff)
{
    memcpy(buff, mein_globales_struct.passkey, PASSKEY_LEN * 2);
}


void get_mac(uint8_t* buff)
{
    memcpy(buff, mein_globales_struct.mac, MAC_LEN);
}


void set_passkey(uint16_t value, uint8_t index)
{
    mein_globales_struct.passkey[index] = value;
}


void set_mac(uint8_t value, uint8_t index)
{
    mein_globales_struct.mac[index] = value;
}


/*  ==================================================  */
/*  Modul B: main.c                                     */

#include <stdio.h>
#include <stdint.h>

#include "mod_a.h"

int main(void)
{
    uint16_t key[ PASSKEY_LEN ];
    uint8_t  mac[ MAC_LEN ];

    get_passkey(key);
    get_mac(mac);

    printf("Key is:");
    for(uint8_t i = 0; i < PASSKEY_LEN; i++) {
        printf(" 0x%X", key[ i ]);
    }
    printf("\n");

    printf("Mac is:");
    for(uint8_t i = 0; i < MAC_LEN; i++) {
        printf(" 0x%X", mac[ i ]);
    }
    printf("\n");


    for(uint8_t i = 0; i < PASSKEY_LEN; i++) {
        set_passkey(0xBEEF + i, i);
    }

    for(uint8_t i = 0; i < MAC_LEN; i++) {
        set_mac(0x10 + i, i);
    }


    get_passkey(key);
    get_mac(mac);

    printf("Key is:");
    for(uint8_t i = 0; i < PASSKEY_LEN; i++) {
        printf(" 0x%X", key[ i ]);
    }
    printf("\n");

    printf("Mac is:");
    for(uint8_t i = 0; i < MAC_LEN; i++) {
        printf(" 0x%X", mac[ i ]);
    }
    printf("\n");

    return 0;
}

[Simon (Gast)]

Auch ne nette Idee, vielen Dank