AVR Projekt: Zugriff auf Funktionen eines anderen c-files

[Furo (Gast)]

Hallo!

Ich steh grad etwas auf dem Schlauch. Ich habe ein Projekt im AVR Studio 
angelegt. Unter Source-File habe ich zwei c-Files mit unterschiedlichen 
Funktionen (nur eine hat die main-funktion). Wie greife ich nun aber von 
einer Funktion aus dem einem c-File auf eine Funktion des andere c-Files 
zu?

Danke für eure Hilfe.

Gruß
Furo

[Patrick (Gast)]

Mache ein header-file für das eine c-file und "include" es dann im 
anderen. In diesem header-file schreibst Du dann den Prototypen zu 
Deiner Funktion, die Du im anderen File verwenden willst.

[Ulrich (Gast)]

so:

funktionsname(parameter)

;-)

Du musst allerdings noch eine Headerdatei anlegen:
zweiteDatei.h

und dort von der Funktion den Prototypen reinschreiben:

z.B. int funktionsname(int paramter1);

[Patrick (Gast)]

Konkret:

Im ersten c-File:
test.c

void Funktion1 (void)
{
 //Code
}

Dann dazu test.h:

extern void Funktion1 (void);

Dann kannst Du im main.c:

#include "test.h"

int main (void)
{
Funktion1();

while(1){..}
return 0;
}

[G. L. (sprintersb)]

Wie gesagt schreibt man ein Header-File, zB foo.h

#ifndef _FOO_H_
#define _FOO_H_ /* vermeidet Probleme bei Mehrfach-Includes */

#define WERT_1 0x1

typedef struct
{
   ...
} data_t;

extern void foo (void);

extern int zahl;

#endif /* _FOO_H_ */

und in foo.c

#include "foo.h"

int zahl = 12;

void foo (void)
{
   zahl = WERT_1;
}

und in bar.c

#include "foo.h"

int main()
{
   foo();

   if (zahl != WERT_1)
      ...
}

Die einzelnen Module können separat compiliert wergen mit gcc und später 
gelinkt

xxx-gcc <optionen> -c foo.c -o foo.o 
xxx-gcc <optionen> -c bar.c -o bar.o 
xxx-gcc <optionen> foo.o bar.o -o foobar.elf

Alternativ kann auch alles zusammen übersetzt werden

xxx-gcc <optionen> foo.c bar.c -o foobar.elf

[Furo (Gast)]

Oh, irgendwie ist das bei mir wohl zu arg verschachtelt.
Da die Funktion der c-Klasse die aufgerufen werden will wieder von 
Methoden abhängt, die in Header-Files definiert sind, die wiederum in 
der "Main-Klasse" eingebunden werden.
Binde ich nun die Header-Files in dem zweiten c-File ein, kommen auch 
viele Meldungen der doppelten Defintion...

[Rufus Τ. F. (rufus)]

> Da die Funktion der c-Klasse die aufgerufen werden will wieder von
> Methoden abhängt, die in Header-Files definiert sind, die wiederum in
> der "Main-Klasse" eingebunden werden.

Du programmierst in C. Das kennt keine Klassen und keine Methoden.


> Binde ich nun die Header-Files in dem zweiten c-File ein, kommen
> auch viele Meldungen der doppelten Defintion...

In Headerdateien gehören Deklarationen, keine Definitionen.

Also keine Funktionen, sondern nur deren Prototypen.

[Furo (Gast)]

Aha .... sonderlich schlauer bin ich jetzt jedoch nicht.

[Rufus Τ. F. (rufus)]

> Binde ich nun die Header-Files in dem zweiten c-File ein, kommen
> auch viele Meldungen der doppelten Defintion...

(...)

> Aha .... sonderlich schlauer bin ich jetzt jedoch nicht.

Dann sieh Dir doch mal so eine Fehlermeldung genauer an und sieh Dir an, 
was Du wo deklariert hast und was Du wo eingebunden hast.

Verwendest Du globale Variablen? Hast Du die in der Headerdatei korrekt 
als extern deklariert?

Wie sehen Deine Funktionsprototypen aus?

Bindest Du etwa auch *.c-Dateien per #include ein?

[Stefan E. (sternst)]

> Aha .... sonderlich schlauer bin ich jetzt jedoch nicht.

Poste doch einfach mal deinen kompletten Code.

[Pete K. (pete77)]

Oder mal ein gutes C-Buch lesen...

[Marco G. (stan)]

das könnte auch helfen:

http://www.mikrocontroller.net/articles/Funktionen_auslagern_%28C%29