STM32 Hilfe bei Nutzung des TIM1_IRQHandler

[Marcus P. (spell)]

Hallo, ich nutze den STM32F107VC und habe bereits den Timer 2 genutzt um 
Interrupts mit Hilfe steigender Flanken auszulösen und so Frequenzen zu 
bestimmmen. Nun möchte ich gern mit Hilfe des Timer 1 zwei Eingänge 
abfragen. Den einen auf steigende und den anderen auf fallende Flanken 
und damit Interrupts auslösen bzw. die Abstände messen. Dazu habe ich in 
die "it.c" Datei nun den "TIM1_IRQHandler"  eingefügt. Setze ich hier 
allerdings Breakpoints kommt es zur Fehlermeldung sobald ich das 
Programm im Debugmodus staren möchte und beim Laden des Programms bleibe 
ich schon im Reset Handler stecken.

Reset_Handler:

/* Copy the data segment initializers from flash to SRAM */
  movs  r1, #0
  b  LoopCopyDataInit

Ist es möglich die beiden Flanken so abzufragen und was mache ich 
falsch?
Ich haben den Code mal auf das Minimum zusammengeschnitten:

Das Hauptprogramm:

#include "stm32f10x.h"
#include <math.h>

// ---------------------------------------------------------

void RCC_Configuration(void);
void TIM_Configuration(void);
void GPIO_Configuration(void);
void NVIC_Configuration(void);
void ADC_Configuration(void);

  int main(void)
  {

    //Konfigurationen
      RCC_Configuration();
      TIM_Configuration();
      GPIO_Configuration();
      NVIC_Configuration();
      ADC_Configuration();

      
//Auswahl Aktivierung der Interrupts

      //Interruptsperre Timer_1
        TIM_ITConfig(TIM1, TIM_IT_CC1, DISABLE);
        TIM_ITConfig(TIM1, TIM_IT_CC3, DISABLE);
        TIM_ITConfig(TIM1, TIM_FLAG_Update, DISABLE);

/*
      //Interruptfreigabe Timer_1
        TIM_ITConfig(TIM1, TIM_IT_CC1, ENABLE);
        TIM_ITConfig(TIM1, TIM_IT_CC3, ENABLE);
        TIM_ITConfig(TIM1, TIM_FLAG_Update, ENABLE);
*/

    while (1)
    {

    }


  }


void RCC_Configuration(void)
{

    RCC_ADCCLKConfig(RCC_PCLK2_Div6);

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1  |
                       RCC_APB2Periph_GPIOC |
                       RCC_APB2Periph_TIM1  |
                       RCC_APB2Periph_GPIOA, ENABLE);
}


void TIM_Configuration(void)
{

  TIM_TimeBaseInitTypeDef      TIM_TimeBaseStructure;
  TIM_ICInitTypeDef        TIM_ICInitStructure;


/*Timer_1 Frequenzmessung*/

  TIM_ICInitStructure.TIM_Channel   = TIM_Channel_1;
  TIM_ICInitStructure.TIM_ICPolarity   = TIM_ICPolarity_Rising;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter   = 0x0;
    TIM_ICInit(TIM1, &TIM_ICInitStructure);

  TIM_ICInitStructure.TIM_Channel   = TIM_Channel_3;
  TIM_ICInitStructure.TIM_ICPolarity   = TIM_ICPolarity_Falling;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter   = 0x0;
    TIM_ICInit(TIM1, &TIM_ICInitStructure);

// Timer_1 Base Konfiguration
  TIM_TimeBaseStructure.TIM_Period       = 0xFFFF;
  TIM_TimeBaseStructure.TIM_Prescaler     = 0;
  TIM_TimeBaseStructure.TIM_ClockDivision    = 0;
  TIM_TimeBaseStructure.TIM_CounterMode     = TIM_CounterMode_Up;
  TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);

// Freigabe der Timer
  TIM_Cmd(TIM1, ENABLE);

}

void GPIO_Configuration(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;


// ADC1 GPIO PC2 (ADC Channel_12) Analoger Eingang
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_AIN;
        GPIO_Init(GPIOC, &GPIO_InitStructure);

// TIM1 channel 1 pin (PA0) steigende Flanke
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOA, &GPIO_InitStructure);

// TIM1 channel 3 pin (PA2) fallende Flanke
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode   = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

}


void NVIC_Configuration(void)
{

NVIC_InitTypeDef       NVIC_InitStructure;


//Konfiguration und Freigabe der ADC Interrupts
  NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);


//Konfiguration und Freigabe Timer_1 Interrupts
  NVIC_InitStructure.NVIC_IRQChannel = TIM1_TRG_COM_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

}

  void ADC_Configuration(void)
  {
  ADC_InitTypeDef ADC_InitStructure;

// ADC1 configuration ------------------------------------------------------
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = ENABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
//  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC3;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 1;
  ADC_Init(ADC1, &ADC_InitStructure);

  // ADC1 regular channel_12 configuration
    ADC_RegularChannelConfig(ADC1, ADC_Channel_12, 1, ADC_SampleTime_28Cycles5);

  //Channel 1 im Diskontinuierlichen Bereich betreiben
  ADC_DiscModeChannelCountConfig(ADC1, 1);

  //Freigabe des diskontinuierlichen Betriebs von ADC1
  ADC_DiscModeCmd(ADC1, ENABLE);

  //Freigabe ADC1 external trigger conversion
  ADC_ExternalTrigConvCmd(ADC1, ENABLE);

  // Enable ADC1 DMA
  ADC_DMACmd(ADC1, ENABLE);

  // Enable ADC1
  ADC_Cmd(ADC1, ENABLE);

  
/*ADC kalibirieren */

    ADC_ResetCalibration(ADC1);
    while(ADC_GetResetCalibrationStatus(ADC1));

    ADC_StartCalibration(ADC1);
    while(ADC_GetCalibrationStatus(ADC1));
  }

Die Interrupts:

void TIM1_IRQHandler(void)
{


//######### Interrupt Überläufe ###############
 if(TIM_GetFlagStatus(TIM1, TIM_FLAG_Update) == SET)
    {
      TIM_ClearFlag(TIM1, TIM_FLAG_Update);
    }


  if(TIM_GetITStatus(TIM1, TIM_IT_CC1) == SET)  //Wenn positive Flanke detektiert wurde
      {
        TIM_ClearITPendingBit(TIM1, TIM_IT_CC1);  //Rücksetzen des Interruptbits

      }

/*
 if(TIM_GetITStatus(TIM1, TIM_IT_CC3) == SET)
  {
  TIM_ClearITPendingBit(TIM1, TIM_IT_CC3);
  }

*/


}