infinite loop, externer Interrupt, STM32F746, HAL-Library

[epika (Gast)]

Hallo,

siehe Code unten. Ich versuche via HAL-Library ein externen 
Interrupt-Eingang zu integrieren.

Sobald der Eingang triggert, stürzt das Programm ab, bzw. geht gemäss 
Debugger in eine "infinite loop", siehe auch Bild Anhang.
Die LED im loop blinkt dann auch nicht mehr.

Was mache ich falsch? :-(
Wo findet man eigentlich all diese HAL-Funktionen/Dokumentation (geht 
das überhaupt ohne CubeMx?)? Aktuell behelfe ich mir da mit der 
Google-Suche. Aber das ist mühsam.

Mit Arduino (stm32duino) kann ich einfach attachInterrupt() machen, und 
es läuft.

#include "stm32f7xx.h"
#include "stm32f7xx_hal_def.h"
#include "../Utilities/STM32746G-Discovery/stm32746g_discovery.h"

static void SystemClock_Config(void);
static void MX_GPIO_Init(void);
void Error_Handler(void);

int main(void)
{

    HAL_Init();
    //NVIC_SetPriority(SysTick_IRQn, -1);

    /* Configure the system clock to 216 MHz */
    SystemClock_Config();
  
    MX_GPIO_Init();




    while (1)
    {
  HAL_Delay(5);
        HAL_Delay(500);
        //HAL_GPIO_TogglePin( GPIOI , GPIO_PIN_8);
        HAL_GPIO_TogglePin( GPIOA , GPIO_PIN_7);
    }
}

static void SystemClock_Config(void)
{
    RCC_ClkInitTypeDef RCC_ClkInitStruct;
    RCC_OscInitTypeDef RCC_OscInitStruct;

    /* Enable Power Control clock */
    __HAL_RCC_PWR_CLK_ENABLE();

    /* The voltage scaling allows optimizing the power consumption when the device is
     clocked below the maximum system frequency, to update the voltage scaling value
     regarding system frequency refer to product datasheet.  */
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

    /*##-1- System Clock Configuration #########################################*/
    /* Enable HSE Oscillator and activate PLL with HSE as source */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLM = 25;
    RCC_OscInitStruct.PLL.PLLN = 400;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    RCC_OscInitStruct.PLL.PLLQ = 8;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);

    /* Activate the Over-Drive mode */
    HAL_PWREx_EnableOverDrive();

    /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
     clocks dividers */
    RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_6);

}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  //__HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOI_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin : PI13 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
  //NVIC_SetPriority(SysTick_IRQn, -1);

}

/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  //HAL_GPIO_TogglePin( GPIOI , GPIO_PIN_8);
  //HAL_GPIO_TogglePin( GPIOA , GPIO_PIN_7);
  /*
  if(GPIO_Pin == GPIO_PIN_13)
  {
  }
  */
  //__NOP();
}
/* USER CODE END 4 */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  /* USER CODE END Error_Handler_Debug */
}

[utzutr (Gast)]

du nutzt zwar die callback .. aber ich vermisse die eigentliche ISR  mit 
der HAL  ISR funktion ( die am ende deine callback aufruft )

[PittyJ (Gast)]

Für z.B. Uart muss ich immer noch eine IQRHandler aktivieren.

void USART3_IRQHandler(void)
{
    HAL_UART_IRQHandler(g_cp_HandleUart[2]);
}

g_cp_HandleUart[] ist mein globales Handle-Array


Vielleicht braucht GPIO das auch so ähnlich?

Die IRQs, die verfügbar sind, stehen bei mir in
startup_stm32h743zitx.s
..
  .word     USART1_IRQHandler
  .word     USART2_IRQHandler
--

[epika (Gast)]

utzutr schrieb:
> du nutzt zwar die callback .. aber ich vermisse die eigentliche ISR  mit
> der HAL  ISR funktion ( die am ende deine callback aufruft )

wird wohl schon im stm32fxx_hal_gpio.c definiert:

__weak void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(GPIO_Pin);
  
  /* NOTE: This function Should not be modified, when the callback is needed,
           the HAL_GPIO_EXTI_Callback could be implemented in the user file
   */
}

Gibt es eigentlich (offizielle) Beispiele/Dokumentation zu dieser 
HAL-Library?

[epika (Gast)]

äh falscher Code, hier wird die Callback aufgerufen, im 
stm32fxx_hal_gpio.c - File:

void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{
  /* EXTI line interrupt detected */
  if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET)
  {
    __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
    HAL_GPIO_EXTI_Callback(GPIO_Pin);
  }
}

[Thilo L. (bc107)]

Kommt mir bekannt vor... Deine INT-Routine wird nicht im 
Interrupt-Vektor eingetragen, sodass dort über den Default Vector bei 
Eintreten eines Interrupts in diese Endlos-Schleife gesprungen wird.
Ich weiß jetzt nicht mehr auswending, was genau ich damals im Code 
ändern musste, aber schau Dir mal Deine Interrupt Vector Table an und 
checke, ob an der relevanten Stelle Deine gewollte INT-Routine 
eingetragen ist.

[Hans (Gast)]

Interrupt Flag wird nicht gelöscht. Deswegen andauernd Interrupts was 
der Compiler wohl als "infinite loop" übersetzt.

[Johannes S. (Gast)]

epika schrieb:
> Wo findet man eigentlich all diese HAL-Funktionen/Dokumentation (geht
> das überhaupt ohne CubeMx?)

z.B. auf github im STM32CubeF7 Repo sind Beispiele und Doku.
Wie schon genannt, fehlt vermutlich die eigentliche ISR und der 
Interrupt landet im Defaulthandler.

https://github.com/STMicroelectronics/STM32CubeF7/blob/e96f98542c6782d97bdd0c50833ee4b70130f3a7/Projects/STM32F746ZG-Nucleo/Examples/GPIO/GPIO_EXTI/Src/stm32f7xx_it.c#L155-L158

[pegel (Gast)]

Ich nutze statt irgend eines Delay immer:

//main.c:
/* USER CODE BEGIN 4 */
void HAL_SYSTICK_Callback(void){
...}
/* USER CODE END 4 */

Um diese zu nutzen, muss ich in der stm32fxxx_it.c im SysTick_Handler 
den Aufruf von HAL_SYSTICK_IRQHandler eintragen, von dem die Funktion 
HAL_SYSTICK_Callback aufgerufen wird.
Dieses Prinzip ist für alle Interrupt/Callback identisch:

void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */
  HAL_SYSTICK_IRQHandler();
  /* USER CODE END SysTick_IRQn 1 */
}

[epika (Gast)]

Thilo L. schrieb:
> aber schau Dir mal Deine Interrupt Vector Table an und
> checke, ob an der relevanten Stelle Deine gewollte INT-Routine
> eingetragen ist.

also CubeMx fügt folgendes im stm32f7xx_it.c hinzu:

void EXTI15_10_IRQHandler(void)
{
  /* USER CODE BEGIN EXTI15_10_IRQn 0 */

  /* USER CODE END EXTI15_10_IRQn 0 */
  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
  /* USER CODE BEGIN EXTI15_10_IRQn 1 */

  /* USER CODE END EXTI15_10_IRQn 1 */
}

und das hier ist schon vorhanden:

void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{
  /* EXTI line interrupt detected */
  if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET)
  {
    __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
    HAL_GPIO_EXTI_Callback(GPIO_Pin);
  }
}

Hans schrieb:
> Interrupt Flag wird nicht gelöscht. Deswegen andauernd Interrupts was
> der Compiler wohl als "infinite loop" übersetzt.

In den Beispielen im Internet, wenn man die Callback 
"HAL_GPIO_EXTI_Callback" verwendet, finde ich keine Zeile die das Flag 
löscht.
Wenn man direkt "void EXTI15_10_IRQHandler(void)" verwendet, dann 
schon... muss ich da noch eine Zeile hinzufügen um das Flag zu löschen? 
Wieso macht CubeMx dies nicht automatisch :-D ??

ijo, nicht einfach....

[epika (Gast)]

epika schrieb:
> Wieso macht CubeMx dies nicht automatisch :-D ??

__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);

wird hier schon gelöscht.
Also lag es wohl am fehlenden Code:

void EXTI15_10_IRQHandler(void)
{
  /* USER CODE BEGIN EXTI15_10_IRQn 0 */
  /* USER CODE END EXTI15_10_IRQn 0 */
  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
  /* USER CODE BEGIN EXTI15_10_IRQn 1 */
  /* USER CODE END EXTI15_10_IRQn 1 */
}

muss ich morgen testen....

[Jens R. (tmaniac)]

Hast du einen ST Link oder anderen Debugger?

Die Infinite Loop ist der Auffangbehälter des ErrorHandlers.
Um zu wissen wie man da hin gekommen ist, muss man den CallStack 
anschauen. Dann kann man auch die ErrorCodes interpretieren welche die 
HAL abspeichert.

[Bingo Bingo (Gast)]

Setze nur mal versuchsweise ein

extern "C"

vor:

void EXTI15_10_IRQHandler(void)