Forum: Mikrocontroller und Digitale Elektronik Fehler beim Aufruf des Interrupts


Fehler beim Aufruf des Interrupts
von Stefan K. (chocco)

Lesenswert?
• ▲
▼ 
Hey Leute,

ich habe ein Problem beim Aufrufen eines Interrupts am STM32 über HAL 
und finde meinen Fehler einfach nicht. Das meiste habe ich dabei über 
CubeMX gemacht.
Dabei handelt es sich um 2 Timer die Synchronisiert sind. TIM2 gibt also 
die Laufzeit für TIM1 vor. Periode/Prescaler usw sind dabei jetzt 
erstmal nebensächlich. Vllt kann mir ja jemand von euch helfen.

Timer Initialisierung
1
/* TIM1 init function */

2
static void MX_TIM1_Init(void)

3
{

4
5
  TIM_SlaveConfigTypeDef sSlaveConfig;

6
  TIM_MasterConfigTypeDef sMasterConfig;

7
  TIM_OC_InitTypeDef sConfigOC;

8
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;

9
10
  htim1.Instance = TIM1;

11
  htim1.Init.Prescaler = 0;

12
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;

13
  htim1.Init.Period = 20;

14
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

15
  htim1.Init.RepetitionCounter = 0;

16
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

17
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)

18
  {

19
    _Error_Handler(__FILE__, __LINE__);

20
  }

21
22
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)

23
  {

24
    _Error_Handler(__FILE__, __LINE__);

25
  }

26
27
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_EXTERNAL1;

28
  sSlaveConfig.InputTrigger = TIM_TS_ITR1;

29
  if (HAL_TIM_SlaveConfigSynchronization(&htim1, &sSlaveConfig) != HAL_OK)

30
  {

31
    _Error_Handler(__FILE__, __LINE__);

32
  }

33
34
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

35
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;

36
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;

37
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)

38
  {

39
    _Error_Handler(__FILE__, __LINE__);

40
  }

41
42
  sConfigOC.OCMode = TIM_OCMODE_PWM1;

43
  sConfigOC.Pulse = 0;

44
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

45
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;

46
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

47
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;

48
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;

49
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)

50
  {

51
    _Error_Handler(__FILE__, __LINE__);

52
  }

53
54
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)

55
  {

56
    _Error_Handler(__FILE__, __LINE__);

57
  }

58
59
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)

60
  {

61
    _Error_Handler(__FILE__, __LINE__);

62
  }

63
64
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;

65
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;

66
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;

67
  sBreakDeadTimeConfig.DeadTime = 0;

68
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;

69
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_LOW;

70
  sBreakDeadTimeConfig.BreakFilter = 0;

71
  sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;

72
  sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;

73
  sBreakDeadTimeConfig.Break2Filter = 0;

74
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;

75
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)

76
  {

77
    _Error_Handler(__FILE__, __LINE__);

78
  }

79
80
  HAL_TIM_MspPostInit(&htim1);

81
82
}

83
84
/* TIM2 init function */

85
static void MX_TIM2_Init(void)

86
{

87
88
  TIM_ClockConfigTypeDef sClockSourceConfig;

89
  TIM_MasterConfigTypeDef sMasterConfig;

90
91
  htim2.Instance = TIM2;

92
  htim2.Init.Prescaler = PWMPRESCALER;

93
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

94
  htim2.Init.Period = 1000;

95
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

96
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

97
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

98
  {

99
    _Error_Handler(__FILE__, __LINE__);

100
  }

101
102
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

103
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)

104
  {

105
    _Error_Handler(__FILE__, __LINE__);

106
  }

107
108
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;

109
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

110
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)

111
  {

112
    _Error_Handler(__FILE__, __LINE__);

113
  }

114
115
}

1
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)

2
{

3
4
  if(htim_base->Instance==TIM1)

5
  {

6
  /* USER CODE BEGIN TIM1_MspInit 0 */

7
8
  /* USER CODE END TIM1_MspInit 0 */

9
    /* Peripheral clock enable */

10
    __HAL_RCC_TIM1_CLK_ENABLE();

11
    /* TIM1 interrupt Init */

12
    HAL_NVIC_SetPriority(TIM1_BRK_TIM15_IRQn, 0, 0);

13
    HAL_NVIC_EnableIRQ(TIM1_BRK_TIM15_IRQn);

14
    HAL_NVIC_SetPriority(TIM1_CC_IRQn, 0, 0);

15
    HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);

16
  /* USER CODE BEGIN TIM1_MspInit 1 */

17
18
  /* USER CODE END TIM1_MspInit 1 */

19
  }

20
  else if(htim_base->Instance==TIM2)

21
  {

22
  /* USER CODE BEGIN TIM2_MspInit 0 */

23
24
  /* USER CODE END TIM2_MspInit 0 */

25
    /* Peripheral clock enable */

26
    __HAL_RCC_TIM2_CLK_ENABLE();

27
    /* TIM2 interrupt Init */

28
    HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);

29
    HAL_NVIC_EnableIRQ(TIM2_IRQn);

30
  /* USER CODE BEGIN TIM2_MspInit 1 */

31
32
  /* USER CODE END TIM2_MspInit 1 */

33
  }


Aufzurufende Funktion
1
//ISR for TIM2

2
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

3
{  

4
  if (htim->Instance == TIM2)

5
  {

6
    speeddelay=SetSpeed(PIDController(winkel2,WISHPOSITION));

7
    

8
    if (error>0)

9
      increment=1;

10
    else if (error<0)

11
      increment=-1;

12
13
    switch (COMMUTATIONMODE)

14
      case 1:

15
      {

16
        static int i=0;

17
        if (i>SIZEOFARRAY-1 && increment ==1)

18
        {

19
          i=0;

20
        }

21
        else if (i<0 && increment==-1)

22
        {

23
          i=SIZEOFARRAY-1;

24
        }

25
        

26
        if(counter==0 || counter%abs((int)(speeddelay))==0)

27
        {

28
          TIM1->ARR = PERIODE;

29
          TIM1->CCR1 = pwmSinU[i];

30
          TIM1->CCR2 = pwmSinV[i];

31
          TIM1->CCR3 = pwmSinW[i];

32
          i=i+increment;

33
          counter++;

34
        }

35
        else

36
        {

37
          counter++;

38
        }

39
    

40
        TIM1->PSC = PWMPRESCALER;

41
        break;

42
      case 2:

43
      {

44
        if(counter==0 || counter%(int)(speeddelay)==0)

45
        {

46
          TIM1->CCR1 = SpwmSin[currentStepA];

47
          TIM1->CCR2 = SpwmSin[currentStepB];

48
          TIM1->CCR3 = SpwmSin[currentStepC];

49
50
          //SPWM

51
          currentStepA = currentStepA - increment;

52
          currentStepB = currentStepB - increment;

53
          currentStepC = currentStepC - increment;

54
 

55
          //Check for lookup table overflow and return to opposite end if necessary

56
          if(currentStepA > sizeOfArray-1)  currentStepA = 0;

57
          if(currentStepA < 0)  currentStepA = sizeOfArray;

58
 

59
          if(currentStepB > sizeOfArray-1)  currentStepB = 0;

60
          if(currentStepB < 0)  currentStepB = sizeOfArray;

61
 

62
          if(currentStepC > sizeOfArray-1)  currentStepC = 0;

63
          if(currentStepC < 0) currentStepC = sizeOfArray; 

64
      

65
          counter++;

66
        }

67
          else

68
            counter++;

69
          TIM1->PSC = PWMPRESCALER;

70
        break;

71
        }

72
      }

73
    }

74
  }


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Fehler beim Aufruf des Interrupts
  


  

    

      von
      
        Daniel (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Was ist denn überhaupt dein Fehler?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Fehler beim Aufruf des Interrupts
  


  

    

      von
      
        Stefan K.
        (chocco)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Daniel schrieb:
> Was ist denn überhaupt dein Fehler?

Das ich gar nicht erst in die Funktion gelange

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Fehler beim Aufruf des Interrupts
  


  

    

      von
      
        Daniel (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Schau mal, ob die Interrupt Handler in der stm32fxxx_it.c erstellt 
worden sind und ob deine Funktion aufgerufen wird.

Gruß,
Daniel

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Fehler beim Aufruf des Interrupts
  


  

    

      von
      
        Stefan K.
        (chocco)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Daniel schrieb:
> Schau mal, ob die Interrupt Handler in der stm32fxxx_it.c erstellt
> worden sind und ob deine Funktion aufgerufen wird.

Das Update Event wird zumindest aufgerufen aber wenn ich Schritt für 
Schritt durchgehe überspringt es PeriodElapsedCallback

1
/* TIM Update event */

2
  if(__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET)

3
  {

4
    if(__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_UPDATE) !=RESET)

5
    { 

6
      __HAL_TIM_CLEAR_FLAG(htim, TIM_FLAG_UPDATE);

7
      HAL_TIM_PeriodElapsedCallback(htim);

8
    }


Liegt dann an GET_IT_Source oder? Sry bin noch relativ neu und brauch 
noch mehr Übung

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Fehler beim Aufruf des Interrupts
  


  

    

      von
      
        Stefan K.
        (chocco)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
hat sich erledigt hab bei der Initialisierung
1
 HAL_TIM_BASE_Start(&htim1)

 statt
1
 HAL_TIM_BASE_Start_IT(&htim1)

  stehen gehabt...

vielen dank für deine Hilfe

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


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
  





  Noch kein Account? Hier anmelden.