Timer/Counter STM32

Gast #3360574
Lesenswert?

Howdie Folks,

ich würde gerne mit einem STM32F407 eine externe Frequenz zählen in 
einem Bereich von 250ms. In diesem Zeitraum möchte ich Rechteckimpulse 
zählen welche an einem Pin anliegen.
Leider steig ich noch nicht so durch mit Timern/Interrupt beim stm32,
vielleicht find ich ja hier Hilfe?
Vilene Dank schonmal
Gast #3360604
Lesenswert?

so oder so ähnlich????

GPIO_InitTypeDef GPIO_InitStructure;

SystemInit();

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, 
ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

TIM_EncoderInterfaceConfig(TIM3, TIM_EncoderMode_TI12, 
TIM_ICPolarity_Rising, TIM_ICPolarity_Falling);

TIM_Cmd(TIM3, ENABLE);
Gast #3360664
Lesenswert?

also kann ich dafür das Encoder-Interface benutzten, dieses bietet ja 
die Möglichkeit, Signale eines Idirekt auszuwerten oder sind 
Rechteckimpulse "andere" Signale als die eines Inkrementalgebers?
#3361598
Lesenswert?

Vieleicht hilft Dir das hier weiter:

http://mystm32.de/doku.php?id=arm_interrupts_in_c

Du musst abhängig von Deiner Frequenz des Timers den Prescaler 
einstellen und die Timer-Periode bestimmen. Vorteiler kannst Du auf 1 
lassen. Und nicht vergessen, einen Takt dem Timer zuzuordnen.

Wenn Dein Timer mit 1 Mhz läuft und Du einen Prescaler von 1000 hast, 
dann läuft Dein Timer mit 1000Hz (1000000/1000=1000).
Setzt Du die Periode auf 100, bekommst Du einen Timer-Überlauf bei 1ms. 
Der Timer zählt mit 1000Hz von 0 bis Periodenende und signalisiert dann 
einen Überlauf.
(1000Hz=0,001s, 100*0,001s=0,1s=1ms)
Gast #3361605
Lesenswert?

Hi Pete,

vielen Dank, die Seite hatte ich auch schon offen,
aber dort wird ein interner Interrupt benutzt,
ich bin davon ausgegangen, dass ich für mein
Problem einen externen Interrupt benötige?!
#3361646
Lesenswert?

Dann hab ich noch einen :-)
http://diller-technologies.de/stm32.html#interrupts_extern

Externen Interrupt konfigurieren und dann mit einem Timer 250ms lang die 
Impulse hochzählen.
oder Du könntest in der ISR des ext. Interrupts die Impulse hochzählen 
und mit einem Timer jeweils alle 250ms den Impulswert sichern und die 
Differenz zum letzten Wert berechnen.
Dann hast Du die Impulse der letzten 250ms.
Gast #3362115
Lesenswert?

bin jetzt auf dem Stand:


void TIM3_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

  /* GPIOC clock enable */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

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

  /* GPIOA Configuration: TIM3 CH1 (PC6) */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; // Input/Output 
controlled by peripheral
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // Button to ground 
expectation
  GPIO_Init(GPIOC, &GPIO_InitStructure);

  /* Connect TIM3 pins to AF */
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_TIM3);

  TIM_TimeBaseStructure.TIM_Period = 21000;
  TIM_TimeBaseStructure.TIM_Prescaler = 1000;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

  TIM_TIxExternalClockConfig(TIM3, TIM_TIxExternalCLK1Source_TI1, 
TIM_ICPolarity_Rising, 0);

  TIM_Cmd(TIM3, ENABLE);

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren