STM32F4 Discovery: Hochfrequenter Timerausgang/Clockfrequenz

[Der M. (naeschd)]

Hallo zusammen,

ich bei gerade dabei mit dem STM32F4 Discovery-Board ein Projekt zu 
verwirklichen um mich so in dem Controller einzulernen...
Ich benötige für mein Projekt ein relativ hochfrequenten Clock, den ich 
mir erzeugen möchte. Bis jetzt habe ich das auf die herkömmliche Weise 
mit einem Timer und Output-Compare gemacht. Jetzt merke ich jedoch, dass 
wenn ich in einen Bereich von ca. 420kHz komme (CCR1-Val < 100), das 
Ganze nicht mehr funktioniert (Der Ausgang wird dann erheblich 
niederfrequenter (ca. 600Hz)).
Anbei mal mein Timercode:

Init:

  //local variable definition
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  TIM_OCInitTypeDef  TIM_OCInitStructure;
  uint16_t PrescalerValue = 0;
  NVIC_InitTypeDef NVIC_InitStructure;

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

  /* Enable the TIM3 gloabal 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);

    /* Initialize Leds mounted on STM32F4-Discovery board */
  STM32F4_Discovery_LEDToggle(LED4);
  STM32F4_Discovery_LEDToggle(LED3);

  /* Turn on LED4, LED3, LED5 and LED6 */
  STM32F4_Discovery_LEDToggle(LED4);
  STM32F4_Discovery_LEDToggle(LED3);


  /* Compute the prescaler value */
  PrescalerValue = (uint16_t) ((SystemCoreClock / 2) / 50000000) - 1;

  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 65535;
  TIM_TimeBaseStructure.TIM_Prescaler = 0;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

  /* Prescaler configuration */
  TIM_PrescalerConfig(TIM3, PrescalerValue, TIM_PSCReloadMode_Immediate);

  /* Output Compare Timing Mode configuration: Channel1 */
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Timing;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = CCR1_Val; //CCR1_Val wird an anderer Stelle initialisiert
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC1Init(TIM3, &TIM_OCInitStructure);
  TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable);

  /* TIM Interrupts enable */
  TIM_ITConfig(TIM3, TIM_IT_CC1 , ENABLE);

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

IRQ:

void TIM3_IRQHandler(void)
{
  static uint8_t pending = 0;
  if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
  {
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
  capture = TIM_GetCapture1(TIM3);
    TIM_SetCompare1(TIM3, capture + CCR1_Val);
  if (pending <= 200)
  {
    pending++;
  }else{
    STM32F4_Discovery_LEDToggle(LED5);
    TLC_PORT->ODR ^= TLC_GSCLK_PIN;  //Zum Testen den Ausgang toggeln lassen
    //TLCdata();
  }
  }
}

Habt ihr eine Idee warum ich mit dieser Konfiguration keinen 
höherfrequenten Takt erzeugen kann? Wenn ja, mit welcher 
Timerkonfiguration kann ich das bewerkstelligen?

Vielen Dank für eure Unterstützung...
Matze

[Der M. (naeschd)]

Sorry für den Push, aber ich bin leider noch nicht weitergekommen.

Ich wäre schon hochzufrieden wenn mir jemand einen Tipp geben könnte wie 
ich mit dem STM32F4 (auf dem Discovery-Board) eine Frequenz an einem 
Ausgang erstellen könnte, die ca. 3MHz beträgt. Am schönsten wäre 
natürlich eine nicht-Interrupt getriebene Lösung. Aber ich weiß nicht ob 
das überhaupt möglich ist.

Nochmal vielen Dank!
Grüße Matze

[holger (Gast)]

>Ich wäre schon hochzufrieden wenn mir jemand einen Tipp geben könnte wie
>ich mit dem STM32F4 (auf dem Discovery-Board) eine Frequenz an einem
>Ausgang erstellen könnte, die ca. 3MHz beträgt.

Wie genau muss die Frequenz sein?
Idee: SPI Modul mit DMA und Circular Mode ohne Memory Increment.
Irgendwas senden und einfach SCK abgreifen.

[Der M. (naeschd)]

Hi!

Danke für deine Antwort. Das Signal muss ein ganz normaler Rechteck sein 
mit Duty cycle 50%. Also ein ganz normaler Rechteck. Die Frequenz ist 
einigermaßen variabel, sollte aber zumindest höher als 2 MHz sein.
Danke für deine Idee. Könntest du da noch genauer eingehen? Also nicht 
im Detail. Circular Mode heißt zyklisch senden oder? Und was bedeutet 
Memory Increment?

Danke nochmal!
Grüße
Mathias

[holger (Gast)]

>Circular Mode heißt zyklisch senden oder?

Ja.

> Und was bedeutet Memory Increment?

Ohne Increment sendest du immer nur einen Wert aus einer
festen Adresse ohne die Speicheradresse für das DMA weiter zu zählen.
Also irgendeine Variable anlegen und deren Adresse für das DMA
eintragen. Was da drin steht ist für deinen Zweck egal.

Ob das so klappt müsste ich auch erst mal ausprobieren.
Ist nur so eine Idee;)

[Verwirrter Anfänger (Gast)]

Ich hab gerade nicht die geistige Kapazität das Problem in deinem Code 
zu suchen aber der unten stehende Code schnipsel gibt mir irgendwas im 
MHz-Bereich aus:

  GPIO_InitTypeDef GPIO_InitStructure;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
  TIM_OCInitTypeDef TIM_OCInitStructure;

  // Enable Pin
  // TIM3 clock enable
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  // GPIOB Configuration:  TIM3 CH2 (PB5)
  GPIO_InitStructure.GPIO_Pin = CAMERA_EX_CLK;
  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_UP;
  GPIO_Init(CAMERA_PORT, &GPIO_InitStructure);

  // Connect TIM3 pins to AF2
  GPIO_PinAFConfig(CAMERA_PORT, GPIO_PinSource5, GPIO_AF_TIM3);

  //  PrescalerValue = (uint16_t) ((SystemCoreClock /2) / 28000000) - 1;
  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 1;
  TIM_TimeBaseStructure.TIM_Prescaler = 0; //No prescaler
  TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV2;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

  /* PWM1 Mode configuration: Channel2 */
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 1;
  TIM_OC2Init(TIM3, &TIM_OCInitStructure);
  TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);

  TIM_ARRPreloadConfig(TIM3, ENABLE);
  /* TIM3 enable counter */
  TIM_Cmd(TIM3, ENABLE);
  TIM3->CCR2 = 1;

[Jörn (Gast)]

Hast du noch einen MCO Ausgang am Chip frei?

An dem kannst du u.U. über die PLL deinen Takt einstellen. Such im 
Datenblatt nach "Clock tree" dort ist ein Blockdiagramm dabei.

Gruß Jörn

[Thomas W. (ratos)]

Der Matze schrieb:
> Ich wäre schon hochzufrieden wenn mir jemand einen Tipp geben könnte wie
> ich mit dem STM32F4 (auf dem Discovery-Board) eine Frequenz an einem
> Ausgang erstellen könnte, die ca. 3MHz beträgt. Am schönsten wäre
> natürlich eine nicht-Interrupt getriebene Lösung. Aber ich weiß nicht ob
> das überhaupt möglich ist.
> Das Signal muss ein ganz normaler Rechteck sein
> mit Duty cycle 50%


Kannst du nicht ganz normal PWM mit TIM_Period=27 (84MHz/3MHz-1) nehmen 
(vorrausgesetzt das Board läuft mit 168 MHz)?