Halbe SYSCLK Geschwindigkeit beim STM32F205 PLL

[Albert F. (afc_audio)]

Moin zusammen, lange hier nichts mehr gepostet. Und jetzt wo ich dran 
brin... kommt erstmal ne Frage.

Ich habe ein selbstentwickeltes STM32F205 Board, der Hardwaremäßig 
funktioniert. Flashen, programmieren, LEDs blinken, alles toll.

I möchte jetzt die Frequenz des SYSCLK auf ~98 MHz erhöhen (12.288 MHz 
Kristall x 8), leider bekomme ich beim Ausgang des PLLs nur die Hälfte? 
Um das zu testen, habe ich ein SysTick timer konfiguriert, der jede 1000 
Ticks ein Interrupt auslöst. Da wird kurz mal ein LED hoch und runter 
geschaltet.

Gemessen am Oszi funktioniert der SysTick ganz gut bei HSI oder HSE (je 
16 oder 12.288 KHz Signal), aber wie gesagt, beim PLL, zeigt es dann nur 
49 KHz statt erwarteten 98 KHz.

Weiter runter habe ich das Code mit Kommentare. Und Entschuldigung wenn 
mein Deutsch etwas komisch klingt, wohne seit ein paar Jahren nicht mehr 
in DE!

Albert

#include "typedef.h"

#include "stm32f2xx.h"
#include "stm32f2xx_it.h"

#include "digIo.h"

void initFlash(void);
void initClocks(void);

char ledsOn = 0x1;

int main(void){

    initFlash();
    initClocks();

    /** Set timer to 98 KHz **/
  if (SysTick_Config(1000))
  {
    /* Capture error */
    while (1);
  }

    initLEDS();

    setLED_Off(0);
    setLED_Off(1);
    setLED_Off(2);
    setLED_Off(3);

    setLED_On(0);
    setLED_On(1);
    setLED_On(2);
    setLED_On(3);

    while(1){

        if(timerExpired == 1){
            timerExpired = 0;

            setLED_On(3);
            setLED_Off(3);
        }
    }

}

void initFlash(void){

  /** Set three wait states **/
  FLASH->ACR |= FLASH_ACR_LATENCY_3WS ;
}

void initClocks(void){

  /** Initialize clock to external clock (12.288 MHz) **/
  RCC->CR |= RCC_CR_HSEON;
  while(!(RCC->CR & RCC_CR_HSERDY)){
    ;
  }

  /** Set PLL source to HSE **/
  RCC->PLLCFGR |= RCC_PLLCFGR_PLLSRC_HSE;

  /** Set M divider to 0x8 (/8) **/
  RCC->PLLCFGR |= (RCC_PLLCFGR_PLLM_3);

  /** Set N multiplier to 0x80 (x128) **/
  RCC->PLLCFGR |= (RCC_PLLCFGR_PLLN_7);

  /** Set P divider to 0x0 (/2) **/
  RCC->PLLCFGR &= ~(RCC_PLLCFGR_PLLP);

  /** Enable PLL **/
  RCC->CR |= RCC_CR_PLLON;
  while(!(RCC->CR & RCC_CR_PLLRDY)){
    ;
  }

  /** Set SW to PLL **/
  RCC->CFGR |= RCC_CFGR_SW_PLL;
  while(!(RCC->CFGR & RCC_CFGR_SWS_PLL)){
    ;
  }
}

[Nico (Gast)]

Weiß der Systick davon etwas?
Laut CMSIS im syste_stm32f4xx.c z.B. muss nach einem Ändern der Core 
Clock noch nen SystemCoreClockUpdate() durchgeführt werden.

https://github.com/mbedmicro/mbed/blob/master/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F4XX/system_stm32f4xx.c#L259

Das müsste beim F2 ja ähnlich sein?!?

[Albert F. (afc_audio)]

Ich meine in dem Fall ist der SystemCoreClock nur der Wert des 
erwarteten PLL Ausgangs.

Bei SysTick_Config(1000) heisst es (so wie ich das verstehe), nach 1000 
ticks (clocks), löse Interrupt aus.

Man kann auch SysTick_Config(SystemCoreClock/1000) konfigurieren, dann 
kommt der Interrupt eben alle 1 ms. Deswegen wird der Wert 
SystemCoreClock neu geschrieben.

Ich werde nochmal weiterschauen, mir ist aufgefallen ich habe was an 
Flash wait states und prefetch vergessen.

[Albert F. (afc_audio)]

Lösung gefunden.

Es scheint als ob man das RCC->PLLCFGR register in einem Schritt 
beschreiben muss. So sieht es jetzt aus

void initClocks(void){

  /** Initialize clock to external clock (12.288 MHz) **/
  RCC->CR |= RCC_CR_HSEON;
  while(!(RCC->CR & RCC_CR_HSERDY)){
    ;
  }

  /** Flash configuration **/
    /** Flash prefetch and cache ON, Flash 3 wait state **/
    FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN | FLASH_ACR_LATENCY_3WS;

  /** Set M divider to 0x8 (/8) **/
  /** Set N multiplier to 0x80 (x128) **/
  /** Set P divider to 0x0 (/2) **/
  /** Set PLL source to HSE **/
    RCC->PLLCFGR = (0x8 | ((uint32_t)0x80 << 6) | (((0x2 >> 1) -1) << 16)) | (RCC_PLLCFGR_PLLSRC_HSE);

  /** Enable PLL **/
  RCC->CR |= RCC_CR_PLLON;
  while(!(RCC->CR & RCC_CR_PLLRDY)){
    ;
  }

  /** Set SW to PLL **/
  RCC->CFGR |= RCC_CFGR_SW_PLL;
  while(!(RCC->CFGR & RCC_CFGR_SWS_PLL)){
    ;
  }
}

Un es läuft wie erwartet, schön 98 Khz Interrupts ausgelöst.

Albert.

[Nico (Gast)]

Albert F. schrieb:
> Ich meine in dem Fall ist der SystemCoreClock nur der Wert des
> erwarteten PLL Ausgangs.
>
> Bei SysTick_Config(1000) heisst es (so wie ich das verstehe), nach 1000
> ticks (clocks), löse Interrupt aus.

Ah, richtig. Das habe ich elegant überlesen.

Danke noch für den Hinweis. Bei mir ist aktuell der PLLCFGR zwar in 
einem durch, aber man weiß ja nie, was man daran mal ändern will.