Definitionsproblem

[Marcel K. (viewer)]

Hallo Forumgemeinde,

ich habe da ein "Definitionsproblem" :o)

folgende Situation:

-------------------------------------------------
spi.c

void spi_putchar(unsigned char data)
{
 ...
}

unsigned char spi_getchar(void)
{
 ...
}
-------------------------------------------------
spi.h

extern void spi_putcher(unsigned char data);
extern unsigned char spi_getchar(void);
-------------------------------------------------

soweit so gut...

jetzt gibt es ein anderes Modul

-------------------------------------------------
lcd.c
#include "lcd.h"
send_data_to_lcd(unsinged char data)
{
 send_spi_data(data);
}

unsigned char get_data_from_lcd(void)
{
 return get_spi_data();
}
-------------------------------------------------
lcd.h
#include "spi.h"

#define send_spi_data(value)    (spi_putchar(value))

So und jetzt mein Problem!!!
Wie geht’s weiter, ich sehe vor lauter Bäumen den Wald nicht mehr!!

#define (value) get_spi_data()  ( value = spi_getchar())

Das geht so nicht :o(

Es hat doch bestimmt jemand hier einen Tip für mich, oder??

Viele Grüße und noch nen schönen Abend euch allen (",),
Marcel

[Rufus Τ. F. (rufus)]

Einfach so weitermachen wie am Anfang, mit ein paar kleinen Änderungen:

-------------------------------------------------
lcd.c

#include "spi.h"

#include "lcd.h"
void send_data_to_lcd(unsinged char data)
{
 spi_putchar(data);
}

unsigned char get_data_from_lcd(void)
{
 return spi_getchar();
}

1. Die #include-Anweisung für spi.h gehört in lcd.c, nicht in lcd.h

2. Die Funktion send_data... braucht einen Rückgabewert. void, da sie 
nichts zurückgibt.

3. Wenn in spi.h Funktionen deklariert werden, dann kann man die auch 
benutzen.

lcd.h

void send_data_to_lcd(unsigned char);
unsigned char get_data_from_lcd(void);

Mehr muss in der Headerdatei nicht drinstehen.

[Klaus W. (mfgkw)]

ein bißchen mehr wäre nützlich:

#ifndef _LCD_H_
#define _LCD_H_

void send_data_to_lcd(unsigned char);
unsigned char get_data_from_lcd(void);

#endif

[Marcel K. (viewer)]

Hallo,
danke für eure Antwort. Mir ist klar wie man das programmiert. Das ganze 
war nur ein kleines Beispiel um es zu erklären. Die Fkt. gibt es so 
natürlich nicht!!
Ich möchte wissen ob man über ein #define auch einen Wert zurückgeben 
lassen kann. Alles was ich bis jetzt gesehen habe, ist das man Werte 
"bekommt" und diese verändern kann. Wie kann ich aber über ein #define 
einen Wert zurückgeben. Also ein unsigned char spi_getchar()
Grüße,
Marcel

[Rufus Τ. F. (rufus)]

Du solltest in Deinem C-Buch mal durchlesen, was ein #define ist und was 
der Präprozessor daraus macht.

[Christian H. (netzwanze)]

#define send_spi_data(value)    spi_putchar(value)

Aufruf:
send_spi_data('a');

#define get_spi_data()  spi_getchar()

Aufruf:

result = get_spi_data();


Geht doch. Ist aber nicht wirklich schön, sowas mit Defines zu machen.

[Marcel K. (viewer)]

Hallo Christian H,
SUPER, vielen Dank!! Das habe ich gesucht. Ich weiß, dass so ein Makro, 
gerade beim debuggen, nicht schön ist. Mich hat es einfach nur 
interessiert!!!

Aber ich habe da trotzdem noch eine Frage. Generell sagt man doch, ein 
[modul.c] beinhaltet sämtliche Funktionen die ein „Ding“ kann oder wie 
man es ansteuert. Der [header.h] stellt die Schnittstelle zu anderen 
Modulen dar. Das [modul.c] sollte so wenig wie möglich von extern 
#includen beeinträchtigt werden und alles über die Schnittstellen seines 
header.h abhandeln. Hätte man z.B. ein Modul das über spi, uart, I2C 
kommunizieren kann und soll vielleicht noch einen Timer starten und den 
ADC auslösen, dann müsste man im modul.c alles includieren.
#include „spi.h“, #include „uart.h“, #include „i2c.h“, #include 
„timer.h“ und #include „adc.h“ Vielleicht noch viel mehr. Würde man das 
ganze aber über die Schnittstellen im header.h machen dann gäbe es 5 
#defines im header.h und das modul.c wäre frei von externen #includes.

Mir ist schon klar, dass dies fast eine philosophische Frage ist, oder??
Ich habe es bis jetzt auch immer so gemacht wie oben beschrieben. Aber 
je mehr man von externen Modulen verwendet, umso schlechter lässt sich 
ein Projekt modularisieren.

Was meint Ihr?

Gruß Marcel

[Rufus Τ. F. (rufus)]

Marcel K. schrieb:
> Würde man das
> ganze aber über die Schnittstellen im header.h machen dann gäbe es 5
> #defines im header.h und das modul.c wäre frei von externen #includes.

Und? Dafür müsste jedes andere Modul, das auf Funktionen aus dem Modul 
zugreift, das ganze Geraffel wiederum mit "header.h" einbinden, obwohl 
es für die anderen Module völlig irrelevant ist.

Ich sehe hier keinen Vorteil in der Verwendung solcher #define-Orgien.

[Marcel K. (viewer)]

Naja, das stimmt natürlich schon!!


Wie sieht das mit Definitionen aus, die nur das Modul betreffen??

Bis jetzt hatte ich im Modul fast nur Funktionen. Die benötigten 
#defines die z.T. nur für das Modul benötigt wurden, hatte ich im Header 
stehen. Somit habe ich das Gerät oder "Ding" eigentlich im Header 
"beschrieben". Damit sind diese aber auch "sichtbar" für andere Module. 
Aber eigentlich sollte doch sämtliche Modul- Definitionen im Modul 
stehen und nur "globale" Defines im Header stehen, oder??

Gruß Marcel

[Rufus Τ. F. (rufus)]

Sofern diese Definitionen wirklich nur das Modul selbst betreffen und 
außerhalb des Modules uninteressant sind, können sie auch im Modul 
untergebracht werden. In der die Schnittstelle nach "außen" 
beschreibenden Headerdatei hat sowas jedenfalls nichts verloren.