IAR + STM32: Linker-Fehler

[user (Gast)]

Hallo,

ich verwende in zwei C Dateien jeweils den gleichen Interrupt-Handler.

void EXTI15_10_IRQHandler(void)
{

}

Allerdings für die ankommenden Ereignisse benutze nicht die gleichen 
Pins.
Beim Kompilieren funktioniert alles. Nur beim Linken erhalte ich diese 
Fehlermeldung:

Error[Li006]: duplicate definitions for "EXTI15_10_IRQHandler";

Müsste ich diesen Interrupt-Handler NUR in eine C Datei aufrufen?

[Dr. Sommer (Gast)]

user schrieb:
> Müsste ich diesen Interrupt-Handler NUR in eine C Datei aufrufen?

Ja. Du kannst nicht 2 Funktionen mit dem gleichen Namen haben. Du kannst 
ja mehrere verschiedene Funktionen schreiben, und diese vom "richtigen" 
Handler aus aufrufen.

[user (Gast)]

Danke erstmal. Gibt es hierzu ein kleines Beispiel?

[Dr. Sommer (Gast)]

Wo brauchst du beim Aufruf von Funktionen ein Beispiel?!

// Datei1.c
void my_2nd_EXTI_Handler (void);

void EXTI15_10_IRQHandler(void)
{
  // ...
  my_2nd_EXTI_Handler ();
}

// Datei2.c

void my_2nd_EXTI_Handler (void) {
  // ...
}

[Little B. (lil-b)]

z.B. so:

/**
 * @brief  Interrupt Service routine EXTI 10 to 15
 * @ingroup  ELWMD_EXTI_Private
 * @brief
 * The service routine for external interrupt lines 10 to 15. Only active, if an user
 * callback function was registered for one of these lines.
 * @param  none
 * @return  nothing
 */
void EXTI15_10_IRQHandler () {
  // save exti-flags associated with this IRQ
  uint32_t line_backup = EXTI->PR & 0xFC00;

  // call user-callbacks according to flags
  if ( (line_backup & 0x400) && (ELWMD_Exti_UserCallbacks[10] != 0) ) ELWMD_Exti_UserCallbacks[10]();
  if ( (line_backup & 0x800) && (ELWMD_Exti_UserCallbacks[11] != 0) ) ELWMD_Exti_UserCallbacks[11]();
  if ( (line_backup & 0x1000) && (ELWMD_Exti_UserCallbacks[12] != 0) ) ELWMD_Exti_UserCallbacks[12]();
  if ( (line_backup & 0x2000) && (ELWMD_Exti_UserCallbacks[13] != 0) ) ELWMD_Exti_UserCallbacks[13]();
  if ( (line_backup & 0x4000) && (ELWMD_Exti_UserCallbacks[14] != 0) ) ELWMD_Exti_UserCallbacks[14]();
  if ( (line_backup & 0x8000) && (ELWMD_Exti_UserCallbacks[15] != 0) ) ELWMD_Exti_UserCallbacks[15]();

  // clear previously saved exti-flags
  EXTI_ClearITPendingBit(line_backup);
  return;
}

[user (Gast)]

Dieser Interrupt-Handler verwende ich zum einen für die 
Ethernet-Kommunikation und zum anderen in einer anderen Klasse für GPIO.
Damit der Code übersichtlich bleibt müsste ich dann eine separate 
Interrupt Datei erstellen in der die Interrupt-Handler-Routine vorhanden 
ist. Dann müsste ich jeweils die Daten bei einem ankommenden Ereignis in 
den entsprechenden Klassen weiterverarbeiten.

[Little B. (lil-b)]

user schrieb:
> Dieser Interrupt-Handler verwende ich zum einen für die
> Ethernet-Kommunikation und zum anderen in einer anderen Klasse für GPIO.

Hää?

EXTI15_10 behandelt nicht den Ethernet Interrupt. Der Ethernet Wakeup 
Interrupt (EXTI19) ist IRQn 62 und wird mittels ETH_WKUP implementiert. 
Dieser wird aber auch nicht zwingend für Ethernet Kommunikation 
gebraucht.

Solltest du jedoch einen externen Ethernet Controller verwenden, dann 
solltest du die Interrupt Pins über deine GPIO-Klasse auswerten.

...oder du hast ein falsches Konzept gewählt.

[user (Gast)]

Den ETH_WKUP Interrupt verwende ich auch nicht. Den EXTI15_10_IRQHandler 
verwende ich eigentlich nur um festzustellen, ob Verbindung da ist oder 
nicht. Dazu benutze ich EXTI_Line14. In einer anderen Klasse für GPIO 
verwende ich ebenfalls den EXTI15_10_IRQHandler allerdings EXTI_Line10.
Alle hardwareabhängigen Codestellen werden immer in einer eigenen C bzw. 
H Datei festgelegt. Blöde wäre jetzt für mich, dass ich den 
EXTI15_10_IRQHandler in einer eigenen C Datei implementieren müsste. 
Hmmm...das macht das ganze unübersichtlich.

[Little B. (lil-b)]

user schrieb:
> Alle hardwareabhängigen Codestellen werden immer in einer eigenen C bzw.
> H Datei festgelegt.

user schrieb:
> Hmmm...das macht das ganze unübersichtlich.

Da geb ich dir Recht, das macht es wirklich unübersichtlich, und auch 
schwer Wartbar und Portierbar. Besser du fasst alle Hardware 
Abhängigkeiten in einem Softwaremodul zusammen. (lass uns dieses 
Softwaremodul "IOMUX" nennen)

IOMUX kümmert sich um die Initialisierung aller Pins und Alternate 
Functions, damit sich die Schnittstellentreiber nicht mehr darum kümmern 
müssen. Beispiel SPI: Der SPI-Treiber modifiziert nur SPI-Register, 
keine GPIO-Register! So lassen sich Treiber von einem Board auf ein 
anderes portieren, ohne den Code anfassen zu müssen.

IOMUX kann sich dann auch um EXTI kümmern, da diese ja stark von den 
Pins abhängt. Zusätzlich bietet es Makros, die dann die Treiber 
verwenden. z.B. so:

iomux.h
-------
#define SPI_ExtiIrq    EXTI0_IRQHandler
#define UART_ExtiIrq   EXTI3_IRQHandler

#define ETHERNET_ExtiIrq   EXTI14_IRQHandler  /* Dies ist kein Hardware-Handler! */
                                              /* Sonder Teil von EXTI15_10 */


iomux.c
-------

#include "iomux.h"

// externe funktionen bekannt machen
extern void ETHERNET_ExtiIrq ();

//wrapper für exti9_5 und exti15_10
void EXTI15_10_IRQHandler () {
   if (/*line 14*/) ETHERNET_ExtiIrq();
   ...
}

ethernet.c
----------
#include "iomux.h"

void ETHERNET_ExtiIrq () {
   // deine IRQ
}

Dieses konzept muss noch erweitert werden, um die Interrupt Flags zurück 
zu setzen, sowie die initialisierung der EXTI in einer IOMUX_Init().

[user (Gast)]

Erstmal vielen Dank.

Da müsste ich nun einiges bei mir ändern. In der IOMUX sind dann nur die 
GPIO relevanten Dinge + Interrupt für die GPIO's enthalten. In den 
anderen Dateien z.B. für Ethernet sind dann nur die Dinge enthalten die 
nur für die Ethernet Kommunikation notwendig sind.