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
Einfach so weitermachen wie am Anfang, mit ein paar kleinen Änderungen: ------------------------------------------------- lcd.c
1 | #include "spi.h" |
2 | |
3 | #include "lcd.h" |
4 | void send_data_to_lcd(unsinged char data) |
5 | {
|
6 | spi_putchar(data); |
7 | }
|
8 | |
9 | unsigned char get_data_from_lcd(void) |
10 | {
|
11 | return spi_getchar(); |
12 | }
|
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
1 | void send_data_to_lcd(unsigned char); |
2 | unsigned char get_data_from_lcd(void); |
Mehr muss in der Headerdatei nicht drinstehen.
ein bißchen mehr wäre nützlich:
1 | #ifndef _LCD_H_
|
2 | #define _LCD_H_
|
3 | |
4 | void send_data_to_lcd(unsigned char); |
5 | unsigned char get_data_from_lcd(void); |
6 | |
7 | #endif
|
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
Du solltest in Deinem C-Buch mal durchlesen, was ein #define ist und was der Präprozessor daraus macht.
#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.
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
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.
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
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.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.