externer Interrupt STM32F303

[har (Gast)]

Hallo,

ich möchte sobald ein Impuls auf dem Port C, Pin0 vorhanden ist, eine 
LED je nach Zustand an- bzw. ausgeschaltet wird. Verwendet wird der 
STM32F303.

Das Problem ist, dass bei der Interrupt-Handler-Funktion "void 
EXTI0_IRQn(void)" die Fehlermeldung auftaucht: "'EXTI0_IRQn' redeclared 
as different kind of symbol".
Aber diesen Namen finde ich so in der Library "stm32f30x.h".

Ich bin für jeden Rat und Tipp dankbar!

void external_clock_detection_Configuration(void)
{
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOE, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure;
    EXTI_InitTypeDef EXTI_InitStructure;

    // external Clock should be detected on Port C, Pin0
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource0);

    EXTI_InitStructure.EXTI_Line = EXTI_Line0;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);
}

void EXTI0_IRQn(void)
{
  EXTI_ClearITPendingBit(EXTI_Line0);
  // blinking LED:
  if(GPIO_ReadOutputDataBit(GPIOE, GPIO_Pin_8)){
    GPIO_WriteBit(GPIOE, GPIO_Pin_8, RESET);
  }else
  {
      GPIO_WriteBit(GPIOE, GPIO_Pin_8, SET);
  }
}

[rtfm (Gast)]

n ist ein Platzhalter

[Jim M. (turboj)]

har schrieb:
> Das Problem ist, dass bei der Interrupt-Handler-Funktion "void
> EXTI0_IRQn(void)" die Fehlermeldung auftaucht: "'EXTI0_IRQn' redeclared
> as different kind of symbol".
> Aber diesen Namen finde ich so in der Library "stm32f30x.h".

Eben deswegen darfste den ja auch nicht mehr als Funktionsnamen 
einsetzen,
denn der ist schon als Enum definiert.

Der korrekte Name für den Interrupt Handler wäre

void EXTI0_IRQHandler(void) {

}

Siehe z.B: 
https://github.com/espruino/Espruino/blob/master/targetlibs/stm32f3/lib/startup_stm32f30x.s

[har (Gast)]

Jim M. schrieb:
> Der korrekte Name für den Interrupt Handler wärevoid
> EXTI0_IRQHandler(void) {
>
> }

Danke. Die Fehlermeldung ist nun weg.
Aber ein Interrupt wird trotzdem nicht ausgelöst, sobald ein clock am 
Pin vorhanden ist.
Erkennt jemand im Code einen Fehler oder ist die Konfiguration eventuell 
unvollständig?

[rtfm (Gast)]

die ganze Show mit Cube MX:
a) stm32f3xx_it.c
void EXTI0_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}

b) stm32f3xx_hal_gpio.c
void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{
  if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET)
  {
    __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
    HAL_GPIO_EXTI_Callback(GPIO_Pin);
  }
}

__weak void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  UNUSED(GPIO_Pin);
}

die als __weak deklarierte Funktion kann vom Anwender überschrieben und 
erweitert werden.

[Nico W. (nico_w)]

Ich bin jetzt nicht so der HALer, aber muss man dort nicht auch über nen 
NVIC den Interrupt mal anschalten?

[rtfm (Gast)]

wird automatisch generiert und in der main aufgerufen:
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();

schaue jetzt nicht nach, aber die 3 kommen in Frage ...
Ich verwende die HAL um eben nicht alles selbst machen zu müssen.

[Nico W. (nico_w)]

rtfm schrieb:
> wird automatisch generiert

Sicher? Geraten?

Nur mal kurz google angeworfen. Aber für nen Timer benötigt man z.B. 
auch in der stdperiph_lib nen explizites

TIM_Cmd(TIM2, ENABLE);

nach der ganzen Init-Geschichte.

Edit: Nochmal google angeworfen und diesen Schnippsel gefunden.
https://github.com/fboris/stm32f103_example/blob/master/EXTI/main.c

    /* Configure EXTI line */
  EXTI_InitStructure.EXTI_Line = EXTI_Line4;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;  
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line5;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line10;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line11;
  EXTI_Init(&EXTI_InitStructure);
  EXTI_InitStructure.EXTI_Line = EXTI_Line12;
  EXTI_Init(&EXTI_InitStructure);

  /* Enable and set EXTI0 Interrupt to the lowest priority */
  NVIC_InitStructure.NVIC_IRQChannel = EXTI4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
  NVIC_Init(&NVIC_InitStructure);
  NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
  NVIC_Init(&NVIC_InitStructure);

Also nochmal. Doch nur geraten?

[rtfm (Gast)]

>Doch nur geraten?
schon gemacht, mit STM32F0

[Nico W. (nico_w)]

rtfm schrieb:
>>Doch nur geraten?
> schon gemacht, mit STM32F0

Einer Arbeitet mit igrend einer HAL, einer mit stdperiph_lib, einer mit 
CubeMX.

Irgendwo muss halt der Interrupt eingeschaltet werden. Ob das nun 
ausgerechnet in deiner HAL automatisch geschieht, heißt ja nicht dass 
das überall so ist. NVIC_EnableIRQ(irgendwas) fehlt hier anscheinend. 
Ansonsten würde er ja in den Interrupt springen.