STM32 Interrupt Handler

Ja, im Debugger springt er auch nicht rein, leider :/

Guest schrieb:
> Fällt jemandem eventuell auf, warum mein Interrupt nicht ausgelöst wird?

So was macht man systematisch im Debugger (Register der Peripherie 
anschauen):
Zählt der Zähler?
Sind die Registerinhalte so wie gewünscht?
Kommt der Zähler am CC1-Wert vorbei?
Wird dann ein Interrupt asugelöst (Timer register)?
Wird imm NVIC dann das Flag gesetzt?
...

rgds

Naja die Register stimmen wohl oder übel. Das PWM Signal pass.
Bei NVIC kann nicht mehr eingestellt werden.
Keine Ahnung wie ich überprüfen kann ob in Keil der Zähler am CC Wert 
vorbei kommt, aber das muss er ja zwangsläufig wenn er reagieren soll 
sobald der Zähler überläuft.
Wofür wird ein Flag benötigt?

Die Änderung auf
    TIM_ClearFlag(TIM1, TIM_FLAG_Update);
bringt leider auch keine Besserung

Mittlerweile sieht der Code so aus aber er funktioniert leider immernoch 
nicht.
[c]
#include "stm32f0xx.h"
//#include "stm32f0xx_conf.h"
#include "stm32f0xx_gpio.h"
#include "stm32f0xx_tim.h"
#include "stm32f0xx_misc.h"

void ur_sh_led_init(void);
void ur_sh_button_init(void);
void ur_sh_pwm_init(void);
void LED_An(void);
void LED_Aus(void);
void ur_sh_pwm_activate(void);
void ur_sh_pwm_deactivate(void);
//void TIM1_CC_IRQHandler(void);
int Done=0;
int Count=0;
//void NVIC_EnableIRQ(IRQn_t IRQn);

int main(void)
{
  ur_sh_button_init();
  ur_sh_led_init();
  ur_sh_pwm_init();
  while(1){
  if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) && Done==0){
    LED_An();
    ur_sh_pwm_activate();
    Done=1;
    Count=100;
  }
  if (Count==0){
    ur_sh_pwm_deactivate();
                LED_Aus
  }
  }
}

void TIM1_CC_IRQHandler(void){
Count=Count-1;
TIM_ClearFlag(TIM1, TIM_FLAG_Update);
  }

void ur_sh_pwm_init(void){

  GPIO_InitTypeDef           GPIO_InitStructure;
  TIM_OCInitTypeDef         TIM_OC_InitStructure;
  TIM_TimeBaseInitTypeDef   TIM_TimeBase_InitStructure;
  NVIC_InitTypeDef           NVIC_InitStructure;

  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_2);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_2);

  TIM_TimeBaseStructInit(&TIM_TimeBase_InitStructure);
  TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBase_InitStructure.TIM_Period = 49;
  TIM_TimeBase_InitStructure.TIM_Prescaler = 23;
  //TIM_TimeBase_InitStructure.TIM_RepetitionCounter = 49;
  TIM_TimeBaseInit(TIM1, &TIM_TimeBase_InitStructure);

  TIM_OCStructInit(&TIM_OC_InitStructure);
  TIM_OC_InitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OC_InitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
  TIM_OC_InitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC_InitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
  TIM_OC_InitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OC_InitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
  TIM_OC_InitStructure.TIM_Pulse = 25;
  TIM_OC1PreloadConfig(TIM1, TIM_OCPreload_Enable);
  TIM_OC2PreloadConfig(TIM1, TIM_OCPreload_Enable);
  TIM_OC1Init(TIM1, &TIM_OC_InitStructure);
  TIM_OC2Init(TIM1, &TIM_OC_InitStructure);

  TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);

  NVIC_InitStructure.NVIC_IRQChannel = TIM1_CC_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPriority = 0x00;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_EnableIRQ(TIM1_CC_IRQn);
  TIM_ClearFlag(TIM1, TIM_FLAG_Update);
  TIM_ClearITPendingBit(TIM1,TIM_IT_Update);
  //TIM_ClearFlag(TIM1, TIM_FLAG_Update);
}

    void ur_sh_pwm_activate(void){
      TIM_CtrlPWMOutputs(TIM1, ENABLE);
      TIM_Cmd(TIM1, ENABLE);
    }

    void ur_sh_pwm_deactivate(void){
      TIM_CtrlPWMOutputs(TIM1, DISABLE);
      TIM_Cmd(TIM1, DISABLE);
    }

Hat sich nichts verändert dadurch.
Langsam gehen mir auch die Ideen aus ^^

Hat keiner mehr einen Vorschlag? Steck irgendwie immer noch fest.

Nimm mal

TIM_ITConfig(TIM1, TIM_IT_CC1 | TIM_IT_CC2, ENABLE);