STM32 Input Capture an PC9

[Georg B. (xsitez)]

Hallo Forum,

ich probiere schon seit einigen Stunden rum und lese mich durch diverse 
Foren und Beiträge. Leider habe ich noch nichts gefunden, was mein 
Problem erklärt.

Ausgangssituation:
Ich möchte an PC9 eine Frequenz messen.
1kHz +- max.

Meine bisherige Init hierzu:

  { // counter input configuration PC9
    // variables
    GPIO_InitTypeDef GPIO_InitStructure;
    EXTI_InitTypeDef EXTI_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    // clock peripherals
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);

    // PC9 input
    GPIO_StructInit(&GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    // PC9 for interrupt usage line9
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOC, GPIO_PinSource9);

    // adjust for external interrupt
    EXTI_StructInit(&EXTI_InitStructure);
    EXTI_InitStructure.EXTI_Line = EXTI_Line9;                 // Line9 => PA9 | PB9 | ...
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;                  // line activate
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;        // interrupt mode
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;     // rising edge
    EXTI_Init(&EXTI_InitStructure);

    // EXTI_Line9 activation and prio
    NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;         // adjust for external interrupt line9
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01; // max prio
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;      // 2nd prio
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            // activate int
    NVIC_Init(&NVIC_InitStructure);
  }

Interrupt:

void EXTI9_5_IRQHandler(void)
{
  // do not enter twice
  if(EXTI_GetITStatus(EXTI_Line9) != RESET)
  {
    // count the interrupts received, reset is done by time period (devtimer.c)
    u32Interrupts++;

    // clear the EXTI line 9 pending bit
    EXTI_ClearITPendingBit(EXTI_Line9);
  }
}

Dieser muß natürlich in stm32f10x_it.h als Prototyp bekanntgemacht 
werden.

void EXTI9_5_IRQHandler(void);  // this line for EXTI Line9

"Abgeholt" wird das Ganze von einem zweiten Interrupt, der alle 500ms 
den gezählten Wert in u32Interrupts ausliesst und rücksetzt.

Frequenz = u32Interrupts * 4; // calc frq
u32Interrupts = 0;            // reset for next time period

Mein Problem ist jetzt, dass der Interrupt EXTI9_5 etwa 9% zu viel 
zählt.
Trotz Entprellung in Hardware (10nF) und "sauberer" Rechteckkurve 
(50:50) vom Funktionsgenerator.

Kann mir hier jemand weiterhelfen?

Grüße,
XSiteZ

[Uwe B. (derexponent)]

Hi Georg B,

bist du sicher das die Zeitbasis von deiner
Tor-Frq mit 500ms GENAU stimmt ?

du kannst zum test mal diese Init Funktion benutzen :
(hier für STM32F4 ...musst du event. abändern)

  GPIO_InitTypeDef   GPIO_InitStructure;
  EXTI_InitTypeDef   EXTI_InitStructure;
  NVIC_InitTypeDef   NVIC_InitStructure;

  // Clock enable (GPIO)
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

  // Config als Digital-Eingang
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
    
  // Clock enable (SYSCONFIG)
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); 

  // EXT_INT9 mit Pin verbinden
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource9);

  // EXT_INT9 config
  EXTI_InitStructure.EXTI_Line = EXTI_Line9;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);

  // NVIC config
  NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

und...warum benutzt du nicht einen Timer im "Input-Capture-Mode" ?
wäre das nicht einfacher ?

Gruss Uwe

[Georg B. (xsitez)]

Hallo,
ich habs mittlerweile am Laufen, aber ich habe vermutlich ein 
Performace-Problem bei ca 1kHz. Kann das sein?
Die Kurve am Oszi ist ok. Trotzdem bricht die berechnete Frequenz ein.
Ein Überlauf kann es nicht sein. Ist alles uint32_t. Das müßte ja ewig 
ausreichen...
Danke für den Tip Uwe. Ich werde dem nachgehen.
So wie es jetzt ist, ist es nicht praktikabel.
Ich melde mich, würde mich aber über Anregungen freuen, da ich bisher 
mit STM32 Timern nicht viel am Hut hatte.
Grüße,
XSiteZ

[Uwe B. (derexponent)]

>aber ich habe vermutlich ein
>Performace-Problem bei ca 1kHz. Kann das sein?

unwahrscheinlich bei 168MHz CLock :-)


>Ein Überlauf kann es nicht sein. Ist alles uint32_t. Das müßte ja ewig
>ausreichen

wenn du alle 500ms den Counter-Wert sicherst und einen Clock von 1kHz 
hast, dann dürfte da nur ein Wert von 500 drinnstehen...reicht also 
locker


hier mal ein Beispiel für InputCompare
mit TIM3/CH4 an PC9

static uint32_t messwert=0;


void init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  TIM_ICInitTypeDef  TIM_ICInitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;


  // Clock Enable
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

  // Config des Pins als AF-Input
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOC, &GPIO_InitStructure);

  // Alternative-Funktion mit dem IO-Pin verbinden
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_TIM3);

  // Clock enable
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  // Vorteiler einstellen (83 => 1MHz)
  TIM_PrescalerConfig(TIM3, 83, TIM_PSCReloadMode_Immediate);

  // Channel 4
  TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;
  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 = 0x3;
  TIM_ICInit(TIM3, &TIM_ICInitStructure);

  // Timer enable
  TIM_Cmd(TIM3, ENABLE);

  NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);
}

void TIM3_IRQHandler(void)
{
  static uint16_t pos=0;
  static uint16_t t1=0;
  static uint16_t t2=0;


  if(TIM_GetITStatus(TIM3, TIM_IT_CC4) == SET) {
    // Interrupt Flags loeschen
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);

    if(pos==0) {
      pos=1;
      t1=TIM_GetCapture4(TIM3);
    }
    else {
      pos=0;
      t2=TIM_GetCapture4(TIM3);

      if(t2>=t1) {
        messwert=t2-t1;
      }
      else {
        messwert=(0xFFFF - t1) + t2;
      }
    }
  }
}

bei 1kHz Input am PC9 steht der Messwert bei 1000
wenn dein APB1-Clock bei 42MHz liegt

Gruss Uwe

[Georg B. (xsitez)]

Hallo Uwe,
danke für das Beispiel,
was ich noch vergesen habe: Ich verwende eine STM32F103VE bei 72MHz.
Leider kennt mein Compilerpaket manche der o.g. Funktionen und/oder 
defines nicht. :-(
Ich versuche gerade das umzuschreiben...
Grüße,
XSiteZ

[Uwe B. (derexponent)]

>Leider kennt mein Compilerpaket manche der o.g. Funktionen und/oder
>defines nicht. :-(

bei STM auf der Webseite gibt es für fast alle Anwendungen
Beispielquellcode (den habe ich auch benutzt)

bestimmt gibt es auch ein Beispiel für Input-Capture
mit dem STM32F103VE

musst einfach mal danach suchen
vlt geht das schneller als alle Fehler einzeln zu beseitigen

[Georg B. (xsitez)]

Hallo,
du meinst das hier:
http://www.st.com/web/en/home/catalog/mmc/FM141/SC1169/SS1031/LN1565/PF164491#
-> Design Resources
hat leider nichts passendes.

Hier mein aktuller Anlauf:

  {
    GPIO_InitTypeDef        GPIO_InitStructure;
    TIM_TimeBaseInitTypeDef TIM_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_AFIO, ENABLE );

    // pin PC9 as input
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    // remap TIM3 to PC9 (TIM3_Ch4)
    GPIO_PinRemapConfig( GPIO_FullRemap_TIM3, ENABLE );

    RCC_APB1PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE);

    // init timer (counter)
    TIM_InitStructure.TIM_Period = 65535;
    TIM_InitStructure.TIM_Prescaler = 0;
    TIM_InitStructure.TIM_ClockDivision = 0;
    TIM_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_InitStructure.TIM_RepetitionCounter = 0;

    TIM_TimeBaseInit( TIM3, &TIM_InitStructure );

    // cfg TIM3 for external clock
    TIM_TIxExternalClockConfig( TIM3, TIM_TIxExternalCLK1Source_TI2,
                                TIM_ICPolarity_Rising, 0 );

    RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM3, ENABLE);

    // enable timer
    TIM_Cmd( TIM3, ENABLE );
  }

ein anderer Interrupt macht dann alle 500ms:

    {                                    //
      extern uint32_t u32Frequency;      //
                                         //
      u32Frequency = TIM3->CNT << 1;     // readout
      TIM3->CNT = 0;                     // reset
    }                                    //

Das Problem ist, das es nicht da tut, was es soll.
In u32Frequency stehen irgendwelche zufälligen Werte.
Ich vermute, dass TIM3 einfah so losläuft, ohne auf irgend ein externes 
clock Signal zu warten.

Was mache ich falsch?

Danke für Durchsicht.

Grüße,
XSiteZ

[Uwe B. (derexponent)]

>hat leider nichts passendes

dann hast du nicht lange genug gesucht

mach mal einen download von STSW-STM32054 :

http://www.st.com/web/en/catalog/tools/PF257890

und wenn du da unter : "Project/STM32F10x_StdPeriph_Examples/TIM"

nichts findest...dann schreib nochmal ;-)


>Ich vermute, dass TIM3 einfah so losläuft, ohne auf irgend ein externes
>clock Signal zu warten.

das lässt sich per Debugger prüfen

Gruss Uwe

[Georg B. (xsitez)]

Ich werd nicht.

Ich hab alles fast 1:1 aus dem Beispiel ..Examples\TIM\InputCapture
Natürlich umgeschrieben von PA7 (T3_Ch2) auf PC9 (TIM3_Ch4).

Einzig was ich mehr brauche für diesen Kanal ist ein

GPIO_PinRemapConfig( GPIO_FullRemap_TIM3, ENABLE );

und alles was dem Interrupt einfällt ist Chaos.

Er reagiert auf ein Event am Eingang. Soweit ja mal ganz gut, nur 
eventuell für 0Hz etwas unpraktisch, aber prinzipiell mal nicht 
schlecht.
Nur liefert

TIM_GetCapture4(TIM3);

totalen Datenkram zurück.

Ich werd das Ganze jetzt mal sacken lassen und mich kommende Woche 
nochmal dransetzen.

So ein Mist grrrrr

Bis dann
XSiteZ

_________________________
nur der Vollständigkeit halber:
Init:

{
  TIM_ICInitTypeDef  TIM_ICInitStructure;

  /* TIM3 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  /* GPIOA and GPIOB clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

  NVIC_InitTypeDef NVIC_InitStructure;

  /* Enable the TIM3 global Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  GPIO_InitTypeDef GPIO_InitStructure;

  /* TIM3 channel 4 pin (PC.09) configuration */
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOC, &GPIO_InitStructure);

  /* TIM3 configuration: Input Capture mode ---------------------
     The external signal is connected to TIM3 CH4 pin (PC.09)
     The Rising edge is used as active edge,
     The TIM3 CCR4 is used to compute the frequency value
  ------------------------------------------------------------ */

  TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;
  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(TIM3, &TIM_ICInitStructure);

  GPIO_PinRemapConfig( GPIO_FullRemap_TIM3, ENABLE );

  /* TIM enable counter */
  TIM_Cmd(TIM3, ENABLE);

  /* Enable the CC4 Interrupt Request */
  TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);
}

Interrupt:

// Timer triggered by external signal PC.09
void TIM3_IRQHandler(void)
{
  static uint16_t u16CaptureNumber=0;
  static uint16_t u16Capture1=0;
  static uint16_t u16Capture2=0;
  static uint32_t u32Measurement;
  extern uint32_t u32Frequency;

  if(TIM_GetITStatus(TIM3, TIM_IT_CC4) == SET)
  {
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);

    if(u16CaptureNumber == 0)
    {
      u16CaptureNumber = 1;
      u16Capture1 = TIM_GetCapture4(TIM3);
    }
    else
    {
      u16CaptureNumber = 0;
      u16Capture2 = TIM_GetCapture4(TIM3);
    }

    if(u16Capture2 >= u16Capture1)
    {
      u32Measurement = u16Capture2 - u16Capture1;
    }
    else
    {
      u32Measurement = (0xFFFF - u16Capture1) + u16Capture2;
    }
    u32Frequency = ((uint32_t) SystemCoreClock / u32Measurement) << 1;
    u32Frequency = u32Frequency; // thisisacompilerbreakpoint
  }
}

[Uwe B. (derexponent)]

was eine falsche Klammersetzung so alles ausrichten kann :-)

void TIM3_IRQHandler(void)
{
  static uint16_t u16CaptureNumber=0;
  static uint16_t u16Capture1=0;
  static uint16_t u16Capture2=0;
  static uint32_t u32Measurement;
  extern uint32_t u32Frequency;

  if(TIM_GetITStatus(TIM3, TIM_IT_CC4) == SET)
  {
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);

    if(u16CaptureNumber == 0)
    {
      u16CaptureNumber = 1;
      u16Capture1 = TIM_GetCapture4(TIM3);
    }
    else
    {
      u16CaptureNumber = 0;
      u16Capture2 = TIM_GetCapture4(TIM3);


      if(u16Capture2 >= u16Capture1)
      {
        u32Measurement = u16Capture2 - u16Capture1;
      }
      else
      {
        u32Measurement = (0xFFFF - u16Capture1) + u16Capture2;
      }
      u32Frequency = ((uint32_t) SystemCoreClock / u32Measurement) << 1;
      u32Frequency = u32Frequency; // thisisacompilerbreakpoint
    }
  }
}

aber vorsicht ...da gibt es eine Division durch null, wenn
u16Capture2 = u16Capture1 !!
-> also u32Frequency nur ausrechnen, wenn u32Measurement!=0

und ist diese Zeile notwendig ?

GPIO_PinRemapConfig( GPIO_FullRemap_TIM3, ENABLE );

Gruss Uwe

[Georg B. (xsitez)]

Hallo Uwe,

ich breche die Versuche mit InputCapture hiermit ab.
In der readme vom Beispiel in der STM32F10x_StdPeriph_Lib_V3.5.0 steht 
der kleine Satz

"For Low-density, Medium-density, High-density and Connectivity line 
devices, the minimum frequency value to measure is 1100 Hz.
For Low-Density Value line, Medium-Density and High-Density Value line 
devices, the minimum frequency value to measure is 366 Hz."

Das Konzept ist damit für meine Anwendung nicht geeignet.

Ich brauche eine Frequenzbestimmung für 0..1kHz. (vgl. meine erste Post)
Dazu würde ich gerne TIM3 (PC.09) als extern getriggerten Counter 
betreiben.
Im Prinzip das, was ich in meinem ersten Post bereits am Laufen habe, 
nur möchte ich das Zählen der Interrupts vom Timer (TIM3->CNT) erledigen 
lassen. Damit hat die CPU nicht (im Worst Case) 1000 Sprünge in der 
Sekunde zu und von einem IRQ_Handler, um eine Variable zu ++en.
Performancegründe. Die CPU soll sich auf Wichtigeres konzentrieren...
Danke für deine Unterstützung bis hier her.
Ich denke ich muss mich dann wohl doch durch das Datenblatt wursteln.

Wie immer für Hilfe dankbar.

XSiteZ

[interrobang (Gast)]

ok ist lange her, bin aber via Google hierüber gestolpert.

1KHz mit einem 16Bit counter bei 72MHz messen? Ich vermute mal der 
Counter hat schneller die 65535 grenze geknackt als eine Flanke bei 
1000Hz festgestellt werden kann.

Also musst Du TIM3 ein Prescaler verpassen, so z.B.:

/* Configures the TIMx Prescaler. */
TIM_PrescalerConfig(TIM3, 2000, TIM_PSCReloadMode_Immediate); // 36KHz

[Paul P. (interrobang)]

Georg B. schrieb:
> Hallo Uwe,
>
> ich breche die Versuche mit InputCapture hiermit ab.
> In der readme vom Beispiel in der STM32F10x_StdPeriph_Lib_V3.5.0 steht
> der kleine Satz
>
> "For Low-density, Medium-density, High-density and Connectivity line
> devices, the minimum frequency value to measure is 1100 Hz.
> For Low-Density Value line, Medium-Density and High-Density Value line
> devices, the minimum frequency value to measure is 366 Hz."
>
> Das Konzept ist damit für meine Anwendung nicht geeignet.
>
> Ich brauche eine Frequenzbestimmung für 0..1kHz. (vgl. meine erste Post)
>

jaja, den ganzen text lesen! Das gild wenn der chip mit 72MHz rennt und 
wenn kein Teiler verwendet wird. In dem Example Code von ST wird nämlich 
kein Teiler angwendet und daher die Warnung ;)

[Uwe B. (Firma: TU Darmstadt) (uwebonnes)]

Man koennte auch die Zaehlerueberlaeufe mitzaehlen...

[Werner (Gast)]

/* TIM3 channel 4 pin (PC.09) configuration */
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

Das ist glaube ich falsch. GPIO Mode muss auf alternate function 
gestellt werden und dann noch entsprechend die selbige im entsprechenden 
AFR Register eingestellt werden.

Werner