Bluepill STM32: welche Taktquelle?

[Jürgen (derkleinemuck)]

Hallo
Kann ich in der Arduino IDE mit stm32duino Core ermitteln, welche Clock 
Source für HSC und LSC aktiv ist und welcher Takt? So ganz werde ich aus 
der KAL-Doku nicht schlau.

[Nemopuk (nemopuk)]

Jürgen schrieb:
> Hallo
> Kann ich in der Arduino IDE mit stm32duino Core ermitteln, welche Clock
> Source für HSC und LSC aktiv ist und welcher Takt? So ganz werde ich aus
> der KAL-Doku nicht schlau.

Das kannst du aus den relevanten Registern auslesen. Die Register sind 
im Reference Manual beschrieben.

https://www.st.com/resource/en/reference_manual/cd00171190-stm32f101xx-stm32f102xx-stm32f103xx-stm32f105xx-and-stm32f107xx-advanced-arm-based-32Bit-mcus-stmicroelectronics.pdf

Allerdings wundert mich, dass du diese Einstellung "ermitteln" willst, 
denn sie wird doch von deinem eigenen Programm eingestellt. Du musst 
doch wissen was du eingestellt hast.

Was ist KAL?

[N. M. (mani)]

Nemopuk schrieb:
> Allerdings wundert mich, dass du diese Einstellung "ermitteln" willst,
> denn sie wird doch von deinem eigenen Programm eingestellt.

Er hat vermutlich ein Arduino Projekt. Da wird das vermutlich für ihn 
übernommen und er will nun wissen was da eingestellt wird.

Jürgen schrieb:
> welche Clock Source für HSC und LSC aktiv ist und welcher Takt

Bluepill ist ein F103.
Also hätte ich vermutet da:
https://github.com/stm32duino/Arduino_Core_STM32/blob/main/system/STM32F1xx/system_stm32f1xx.c

[Alexander (alecxs)]

Nemopuk schrieb:
> Was ist KAL?

Kernel Abstraction Layer?

N. M. schrieb:
> Bluepill ist ein F103.
> Also hätte ich vermutet da:

https://github.com/stm32duino/Arduino_Core_STM32/blob/main/variants/STM32F1xx/F103C4T_F103C6(T-U)/variant_BLUEPILL_F103C6.cpp#L116

PLLCLK 72 MHz, LSI 40 kHz

[Jürgen (derkleinemuck)]

N. M. schrieb:
> Er hat vermutlich ein Arduino Projekt. Da wird das vermutlich für ihn
> übernommen und er will nun wissen was da eingestellt wird.
>

Genau. Und ich bin verwirrt, weil ich andere Ergebnisse bekomme.

RCC_ClkInitTypeDef RCC_ClkInitStruct;
HAL_result = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);  
Serial.println(RCC_ClkInitStruct.SYSCLKSource);

liefert "1", was wenn ich mich zu 
https://github.com/stm32duino/Arduino_Core_STM32/blob/main/system/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_rcc.h 
durchhangle und weiter zu rc.h: RCC_CFGR_SW_HSE für den System Clock 
Multiplexer bedeutet. Damit sind aber keine 72MHz möglich, wie bei
HAL_RCC_GetSysClockFreq() oder F_CPU ausgegeben wird.

BTW: Die Bluepill nutzt einen STM32F103C8, was dann wohl 
https://github.com/stm32duino/Arduino_Core_STM32/blob/main/variants/STM32F1xx/F103C8T_F103CB(T-U)/variant_PILL_F103Cx.cpp 
bedeutet - aber gleiche Verwirrung

[Alexander (alecxs)]

HAL_RCC_ClockConfig() liest nur die Felder die du gesetzt hast. Dein 
RCC_ClkInitStruct ist leer.

[Jürgen (derkleinemuck)]

Aha.
Ich habe mit dem hier rumexperimentiert:

void setup() {
  Serial.begin(115200);
  Serial.print("F_CPU=");
  Serial.println(F_CPU);
  Serial.print("HAL_RCC_GetSysClockFreq()=");
  Serial.println(HAL_RCC_GetSysClockFreq());
  Serial.print("HAL_RCC_GetHCLKFreq=");
  Serial.println(HAL_RCC_GetHCLKFreq());
  Serial.print("HAL_RCC_GetPCLK1Freq=");
  Serial.println(HAL_RCC_GetPCLK1Freq());
  Serial.print("HAL_RCC_GetPCLK2Freq=");
  Serial.println(HAL_RCC_GetPCLK2Freq());

  HAL_StatusTypeDef HAL_result;            

  RCC_OscInitTypeDef RCC_OscInitStruct;

HAL_result = HAL_RCC_OscConfig(&RCC_OscInitStruct); 
Serial.println(RCC_OscInitStruct.HSEPredivValue);
Serial.println(RCC_OscInitStruct.HSICalibrationValue);  // 4
Serial.println(RCC_OscInitStruct.HSEState); // 0
Serial.println(RCC_OscInitStruct.HSIState); //0
Serial.println(RCC_OscInitStruct.LSEState);
Serial.println(RCC_OscInitStruct.LSIState);
Serial.println(RCC_OscInitStruct.OscillatorType); // 1 

Serial.println(RCC_OscInitStruct.PLL.PLLMUL);   // 134227185
Serial.println(RCC_OscInitStruct.PLL.PLLSource);  // 0  HSI clock divided by 2 selected as PLL entry clock source */
Serial.println(RCC_OscInitStruct.PLL.PLLState);  // 3

RCC_ClkInitTypeDef RCC_ClkInitStruct;
HAL_result = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);  // Catch the result
Serial.println(RCC_ClkInitStruct.SYSCLKSource);   // 1 < HSE selected as system clock */

}

Nicht schick aber es gibt folgende Ausgaben:

F_CPU=72000000
HAL_RCC_GetSysClockFreq()=72000000
HAL_RCC_GetHCLKFreq=72000000
HAL_RCC_GetPCLK1Freq=36000000
HAL_RCC_GetPCLK2Freq=72000000
4294967295
4
0
0
1073821696
134228100
1
134227205
0
3
1

Wie geht es denn richtig?

[Alexander (alecxs)]

Garbage in garbage out. HAL_RCC_OscConfig() und HAL_RCC_ClockConfig() 
sind rein zum setzen gedacht.

[Jürgen (derkleinemuck)]

Jürgen schrieb:
> Wie geht es denn richtig?

[Alexander (alecxs)]

Es gibt die HAL_RCC_GetOscConfig() und HAL_RCC_GetClockConfig() 
Funktionen, aber auch die nützen nur etwas wenn die Werte über HAL 
gesetzt wurden.

Jürgen schrieb:
> 
https://github.com/stm32duino/Arduino_Core_STM32/blob/main/system/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_rcc.h

hier findest Du die passenden Makros um Register direkt auszulesen, z.B. 
__HAL_RCC_GET_SYSCLK_SOURCE()

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

Jürgen schrieb:

>...
> Wie geht es denn richtig?

Bare-metal fuer F1 und F3 etwa wie

/*!
 * \brief  Update SystemCoreClock according to Clock Register Values
 *
 * This function reads out the CPUs clock and PLL registers and assembles
 * the actual clock speed values into the SystemCoreClock local variable.
 */
static void SystemCoreClockUpdate(void)
{
    uint32_t tmp = 0, pllmult = 0, pllinput = 0;
#if defined(RCC_CFGR2_PREDIV1)
    uint32_t pllmuxinput;
    uint32_t prediv1;
    uint32_t prediv2, pll2multval;
    /* Use value * 2 to get integer value for multiplication factor 6.5 */
    const uint8_t pll1mult[16] = { 0,  0,  8, 10, 12, 14, 16, 18,  0,  0,  0,  0,  0, 13, 0 ,  0};
    const uint8_t pll2mult[16] = { 0,  0,  0,  0,  0,  0,  8,  9, 10, 11, 12, 13, 14,  0, 16, 20};
    uint32_t prediv1factor = 0;
#endif

    /* Get SYSCLK source -------------------------------------------------------*/
    tmp = RCC->CFGR & RCC_CFGR_SWS;

    switch (tmp)
    {
        case RCC_CFGR_SWS_HSI:  /* HSI used as system clock */
            sys_clock = HSI_VALUE;
            break;
        case RCC_CFGR_SWS_HSE:  /* HSE used as system clock */
            sys_clock = HSE_VALUE;
            break;
        case RCC_CFGR_SWS_PLL:  /* PLL used as system clock */
            /* Get PLL clock source and multiplication factor ----------------------*/
            pllmult = RCC->CFGR & RCC_CFGR_PLLMULL;
            pllmult = pllmult / RCC_CFGR_PLLMULL_0;
#if defined(RCC_CFGR2_PREDIV1)
            pllmult = pll1mult[pllmult];
#else
            pllmult = pllmult + 2;
            if (pllmult > 16)
                pllmult = 16;
#endif
            switch (RCC->CFGR & RCC_CFGR_PLLSRC) {
            case 0 :
                pllinput = HSI_VALUE / 2;
                break;
#if defined(RCC_CFGR2_PREDIV1)
            case RCC_CFGR_PLLSRC :
                pllmuxinput = HSE_VALUE;
                prediv1 =  RCC->CFGR2 &  RCC_CFGR2_PREDIV1;
                prediv1 =  prediv1 / RCC_CFGR2_PREDIV1_0;
                switch (RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC) {
                case RCC_CFGR2_PREDIV1SRC_PLL2:
                    prediv2 = (RCC->CFGR2 & RCC_CFGR2_PREDIV2) / RCC_CFGR2_PREDIV2_0;
                    pll2multval = (RCC->CFGR2 & RCC_CFGR2_PLL2MUL) / RCC_CFGR2_PLL2MUL_0;
                    pllmuxinput = (HSE_VALUE * pll2mult[pll2multval]) / (prediv2 + 1);
                    pllinput = pllmuxinput / (prediv1 + 1);
                    break;
                case RCC_CFGR2_PREDIV1SRC_HSE:
                    /* HSE oscillator clock selected as PREDIV1 clock entry */
                    pllinput = HSE_VALUE / (prediv1factor + 1);
                }
                pllinput = pllmuxinput / (2 *(prediv1 + 1));
                break;
#else
            case RCC_CFGR_PLLSRC :
                if (RCC_CFGR_PLLXTPRE_HSE_DIV2 == (RCC->CFGR & RCC_CFGR_PLLXTPRE)) {
                    pllinput = HSE_VALUE / 2;
                } else {
                    pllinput = HSE_VALUE;
                }
                break;
#endif
            }
            sys_clock = pllinput * pllmult ;
            break;
    }
 //   SetClockShift();
}