STM32F103 ADC per Timer triggern (SPL)

[Info (Gast)]

Ich finde leider den Fehler nicht: Capture 2 funktioniert (Interrupt), 
löst aber nicht den ADC aus. Offenbar fehlt etwas - aber was?

#include "stm32f10x_conf.h"

int main(void)
{

    SystemInit();


    // Interrupts
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);

    NVIC_InitTypeDef NVIC_InitStructure;

    NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);


    NVIC_InitStructure.NVIC_IRQChannel = TIM1_CC_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);



    // Clocks

    RCC_ADCCLKConfig(RCC_PCLK2_Div6);

    RCC_APB2PeriphClockCmd(
        RCC_APB2Periph_GPIOA |
        RCC_APB2Periph_GPIOB |
        RCC_APB2Periph_AFIO  |
        RCC_APB2Periph_TIM1  |
        RCC_APB2Periph_ADC1  ,
        ENABLE
        );



    // IO

    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_StructInit(&GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;       // AF: adc
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_Init(GPIOA, &GPIO_InitStructure);


    GPIO_StructInit( &GPIO_InitStructure );

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     // AF: timer 1 pwm
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_Init(GPIOA, &GPIO_InitStructure);


    GPIO_StructInit( &GPIO_InitStructure );

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

    GPIO_Init(GPIOB, &GPIO_InitStructure);



    // ADC

    ADC_InitTypeDef ADC_InitStructure;

    ADC_StructInit(&ADC_InitStructure);

    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC2;
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_NbrOfChannel = 1;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;

    ADC_Init(ADC1, &ADC_InitStructure);

    ADC_RegularChannelConfig(
         ADC1,
         ADC_Channel_1,
         1,                         // The rank in the regular group sequencer. This parameter must be between 1 to 16.
         ADC_SampleTime_1Cycles5
         );

    ADC_ExternalTrigConvCmd(ADC1, ENABLE);

    ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);
    ADC_ITConfig(ADC1, ADC1_2_IRQn, ENABLE);


    ADC_Cmd(ADC1, ENABLE);


    // calibrate
    ADC_ResetCalibration(ADC1);
    while(ADC_GetResetCalibrationStatus(ADC1));

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




/*
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
    while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
    ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
    uint16_t value = ADC_GetConversionValue(ADC1);
*/

    // PWM Timer 1

    TIM_TimeBaseInitTypeDef TIM_TimeBase_InitStructure;

    TIM_TimeBaseStructInit( &TIM_TimeBase_InitStructure );

    TIM_TimeBase_InitStructure.TIM_CounterMode =    TIM_CounterMode_Up;
    TIM_TimeBase_InitStructure.TIM_ClockDivision =  TIM_CKD_DIV1;
    TIM_TimeBase_InitStructure.TIM_Prescaler =      32;
    TIM_TimeBase_InitStructure.TIM_Period =         1023;

    TIM_TimeBaseInit(TIM1, &TIM_TimeBase_InitStructure);



    // CC1 PWM
    TIM_OCInitTypeDef   TIM_OC_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_OCNIdleState = TIM_OCNIdleState_Reset;
    TIM_OC_InitStructure.TIM_OCPolarity =   TIM_OCPolarity_High;
    TIM_OC_InitStructure.TIM_OCNPolarity =  TIM_OCNPolarity_Low;
    TIM_OC_InitStructure.TIM_Pulse =        127;
    TIM_OC_InitStructure.TIM_OutputState =  TIM_OutputState_Enable;
    TIM_OC_InitStructure.TIM_OutputNState = TIM_OutputNState_Disable;
    TIM_OC1Init(TIM1, &TIM_OC_InitStructure);

    TIM_OC1PreloadConfig(TIM1, TIM_OCPreload_Enable);


    // CC2 ADC
    TIM_OCStructInit( &TIM_OC_InitStructure );
    TIM_OC_InitStructure.TIM_Pulse =        511;
    TIM_OC2Init(TIM1, &TIM_OC_InitStructure);

    TIM_OC2PreloadConfig(TIM1, TIM_OCPreload_Enable);


    TIM_ClearITPendingBit(TIM1, TIM_IT_CC2);
    TIM_ITConfig(TIM1, TIM_IT_CC2, ENABLE);



    TIM_Cmd(TIM1, ENABLE);

    TIM_CtrlPWMOutputs(TIM1, ENABLE);



  while(1)
  {

  }
}



void ADC1_2_IRQHandler(void){


        if( ADC_GetITStatus(ADC1, ADC_IT_EOC) == SET){
            ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);

            GPIO_ResetBits(GPIOB, GPIO_Pin_14);
        }
}



void TIM1_CC_IRQHandler(void)
{
    if( TIM_GetITStatus(TIM1, TIM_IT_CC1) == SET ){
        TIM_ClearITPendingBit(TIM1, TIM_IT_CC1);
    }


    if( TIM_GetITStatus(TIM1, TIM_IT_CC2) == SET ){
        TIM_ClearITPendingBit(TIM1, TIM_IT_CC2);

        if(GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_14) == SET)
            GPIO_ResetBits(GPIOB, GPIO_Pin_14);
        else
            GPIO_SetBits(GPIOB, GPIO_Pin_14);

    }
}

[Info (Gast)]

Besser:

    ADC_ITConfig(ADC1, ADC_IT_EOC, ENABLE);

Macht aber keinen Unterschied :-(

[Info (Gast)]

ADC und PWM haben mit alternate functions nichts zu tun, also:

//RCC_APB2Periph_AFIO  |

[Info (Gast)]

Nach Softwaretrigger des ADCs kommt erwartungsgemäß der ADC-Interrupt, 
und mit der anderen Compare-Einheit

ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;

klappt es ebenfalls prinzipiell. Nur mit CC2 nicht.

Es ist offenbar dasselbe Problem wie hier:

Beitrag "STM32: zweites compare-register vom timer verwenden"

[Info (Gast)]

So richtig scheint es doch nicht zu gehen mit CC1: der angebliche 
ADC_IT_EOC fällt immer auf den Timerüberlauf, sprich auf die steigende 
Flanke des PWM-Pulses bei 0.

[Info (Gast)]

Die Doku ist irreführend. Der externe Trigger des ADCs ist kein direktes 
"internes Signal" von der CC, sondern nutzt dessen Ausgangssignal, 
sprich, das (PWM-) Signal, und dort auch nur eine steigende Flanke. Um 
zum Comparezeitpunkt den ADC zu starten, muss also eine invertierte PWM 
erzeugt werden. Sie muss jedoch nicht zwangsläufig über den GPIO 
ausgegeben werden. Allerdings lässt sich dann wahrscheinlich eine 
weitere alternate function für den Pin nicht mehr nutzen, wenn dort 
schon der Timer aktiv ist.

Das ist etwas enttäuschend; ich hätte gedacht, 
timersynchrone/-gesteuerte Messungen wären an der Tagesordnung und daher 
einfach möglich, sprich per echtem, direktem "Event" von der 
Compare-Einheit.