[STM32F429] Generare 1MHz su una GPIO

[DarwinNE]

Buongiorno a tutti,
sto provando a giocare un po' con una scheda STM32F429I-DISC0 che avevo recuperato un po' di anni fa e non avevo ancora avuto modo di provare per davvero. Ho un po' di esperienza con i micro ad 8 bit (HC11 e PIC16F), ma non ho mai usato veramente gli STM32.

Premetto che sono un principiante nel campo, la risposta RTFM mi va benone, mi basta essere indirizzato un pochino perché districarmi in migliaia di pagine in PDF non è affatto facile, per il momento.

Premetto anche che per complicarmi la vita sto usando un sistema di sviluppo molto basilare su macOS, composto in pratica da un makefile (ben lontano dall'essere perfetto) e da una versione della libreria HAL che sono riuscito a far funzionare molti anni fa e che non ho mai avuto il coraggio di aggiornare perché temo di passare ore a correre dietro a file. Non ho mai utilizzato STM32CubeMX per problemi legati al sistema operativo che uso (prima non esisteva per macOS, poi l'ultima versione richiede un OS più recente di quello che sto usando ora). Effettuo il flash tramite St-link da linea di comando:

Codice: Seleziona tutto

st-flash write Display.bin 0x8000000

Per il momento, sono riuscito a scrivere cosettine sul display, far lampeggiare LED, controllare GPIO senza far scorrere troppo sangue. Ora dovrei generare un clock a 1 MHz su un piedino GPIO (mi farebbe comodo PE3, per esempio) e vi devo sincronizzare un po' di avvenimenti (mandare altri segnali, caricare dati su un data bus, etc...).

Finora ho trovato esempi o tutorial su come eseguire un interrupt periodicamente. Non credo che sia il modo migliore per generare un segnale a 1 MHz, ma ho provato questa via comunque senza successo. Ecco la configurazione, ispirata da un tutorial sulla HAL che dovrebbe far lampeggiare un led sulla scheda a 1 Hz:

Codice: Seleziona tutto

void TB_init(void)
{
  /*##-1- Configure the TIM peripheral #######################################*/
  /* -----------------------------------------------------------------------
    In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1),
    since APB1 prescaler is different from 1.   
      TIM3CLK = 2 * PCLK1 
      PCLK1 = HCLK / 4
      => TIM3CLK = HCLK / 2 = SystemCoreClock /2
    To get TIM3 counter clock at 10 kHz, the Prescaler is computed as following:
    Prescaler = (TIM3CLK / TIM3 counter clock) - 1
    Prescaler = ((SystemCoreClock /2) /10 kHz) - 1
       
    Note:
     SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.
     Each time the core clock (HCLK) changes, user had to update SystemCoreClock
     variable value. Otherwise, any configuration based on this variable will be incorrect.
     This variable is updated in three ways:
      1) by calling CMSIS function SystemCoreClockUpdate()
      2) by calling HAL API function HAL_RCC_GetSysClockFreq()
      3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency 
  ----------------------------------------------------------------------- */ 
 
  /* Compute the prescaler value to have TIM3 counter clock equal to 10 kHz */
  uwPrescalerValue = (uint32_t) ((SystemCoreClock /2) / 10000) - 1;
 
  /* Set TIMx instance */
  TimHandle.Instance = TIMx;
   
  /* Initialize TIM3 peripheral as follows:
       + Period = 10000 - 1
       + Prescaler = ((SystemCoreClock/2)/10000) - 1
       + ClockDivision = 0
       + Counter direction = Up
  */
  TimHandle.Init.Period = 10000 - 1;
  TimHandle.Init.Prescaler = uwPrescalerValue;
  TimHandle.Init.ClockDivision = 0;
  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;

  if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
  {
    /* Initialization Error */
    Error_Handler();
  }
 
  /*##-2- Start the TIM Base generation in interrupt mode ####################*/
  /* Start Channel1 */
  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)
  {
    /* Starting Error */
    Error_Handler();
  }
    __HAL_TIM_ENABLE_IT(&TimHandle, TIM_IT_UPDATE);

  BSP_LED_On(LED3);
}


Qui il codice completo, alquanto work in progress:

https://github.com/DarwinNE/MIDI2SwinSI ... src/main.c

Anche se il tutto viene compilato correttamente e l'error handler non è chiamato durante l'esecuzione , la funzione HAL_TIM_PeriodElapsedCallback qui di seguito non viene mai chiamata:

Codice: Seleziona tutto

/**
  * @brief  Period elapsed callback in non blocking mode
  * @param  htim: TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    BSP_LED_Toggle(LED3);
}

A questo punto vorrei sapere:
- Per che motivo HAL_TIM_PeriodElapsedCallback non funziona nel codice di cui sopra? Anche se non è il modo migliore per generare 1 MHz mi rimane comunque la curiosità di risolvere questo problema perché potrebbe essermi utile in futuro applicare questa tecnica.
- Quale strategia sarebbe la migliore da implementare per generare 1 MHz e sincronizzare a richiesta altre modifiche su uscite GPIO?
- A termine che strategia sarebbe la migliore da implementare per aggiornare la HAL (val la pena/non val la pena/meglio cambiare libreria/meglio cambiare hobby)

Grazie

[DarwinNE]

Stavo pensando di generare il segnale tramite il PWM. Qui ho trovato un esempio, ma non ho proprio capito tutto:

http://stm32f4-discovery.net/2014/05/st ... -tutorial/

Come potrei sincronizzare il cambiamento su altre GPIO ad un cambiamento di stato dell'uscita PWM?

[xyz]

Come potrei sincronizzare il cambiamento su altre GPIO ad un cambiamento di stato dell'uscita PWM?

Si usa di solito gli interrupt, si programma lo scatenarsi di un interrupt software quando si modifica lo stato del GPIO. Nel codice dell'interrupt cambi la larghezza dell'impulso o la frequenza o tutte e due del PWM.

[DarwinNE]

Grazie xyz

Cerco di spiegare meglio quello che dovrei fare. Io sto cercando di controllare con lo STM32 un chip esterno (un sintetizzatore) che richiede un clock da 1 MHz. Ogni tanto devo mandare dei messaggi tramite un bus dati ed un bus indirizzi ed alcune linee di controllo che devono essere più o meno sincronizzate con il clock.

[WALTERmwp]

(...) che devono essere più o meno sincronizzate con il clock.

sembra che i segnali su quelle linee non debbano uscire rispettando rigorosamente la griglia del clock.
Ammetto di non aver colto appieno la necessità, scrivo una cosa che può avere un senso o risultare una baggianata perché non realizzabile, una inutile complicazione se non proprio inutile.
Se il segnale del clock venisse riportato anche ad un altro ingresso dello ARM, passato a un contatore(hw, ammettendo la possibilità, non ho guardato il datasheet) per generare in uscita un interrput software per rifasare l'output del bus indirizzi e linee di controllo ?
Sino all'interrupt sarebbe quasi tutto a livello di "silicio".

Saluti

[DarwinNE]

Se devo essere sincero, non sono ancora arrivato al problema della sincronizzazione.

Proprio non riesco a generare un segnale né lanciando un interruzione periodica e cambiando l'uscita a manina, né con un PWM. Ho provato con qualche tutorial, ma non succede nulla e non saprei come trovare il problema...

Sono in difficoltà con le 2100 pagine della guida che descrive la HAL, le 240 pagine del PDF del STM32F429 e le 1700 pagine e rotti della guida del riferimento. E' una quantità di documentazione che eccede di 30 o 40 volte quello che riesco a digerire nel tempo libero. Mi sa che ritorno ai PIC16F

Dimenticavo le 32 pagine che descrivono la schedina, ma quelle sono riuscito più o meno a leggerle...

[WALTERmwp]

Adesso non posso provare ma dovessi alimentare una scheda io utilizzerei STM32CubeMX; senza l'ambiente che agevola(a meno d'essere @xyz) tutto si complicherebbe ancor più, almeno per me.
Prima di mandare il Cortex alle ortiche, se prendi tempo magari riesci ad organizzarti con il software.

Hai provato a compilare il codice dell'esempio del link(l'autore è autorevole, partecipa anche altrove, attivo su FB), e a trasferirlo ?

Saluti

[DarwinNE]

Adesso non posso provare ma dovessi alimentare una scheda io utilizzerei STM32CubeMX; senza l'ambiente che agevola(a meno d'essere @xyz) tutto si complicherebbe ancor più, almeno per me.

Sì, è sicuro, l'ho scaricato ma richiede macOS 14 ed io ho macOS 13.6 perché ho un computer troppo vecchio

Hai provato a compilare il codice dell'esempio del link(l'autore è autorevole, partecipa anche altrove, attivo su FB), e a trasferirlo ?

Se non riuscirò a fare altrimenti è la strada che percorrerò. Mi toccherà scrivere un makefile, però.

[DarwinNE]

Forse ho capito un inghippo... per il momento lavoravo solo su main.c, mi sembra di aver capito che altri file come stm32f4xx_it.c debbano essere adattati a quello che voglio fare...

[gvee]

Ciao,

Il file stm32f4xx_it.c è dedicato all'implementazione delle funzioni di interrupt, che devi abilitare tramite il controllore NVIC (nested vector interrupt controller).

Non conosco la scheda in questione ed ora non posso leggere il datasheet, però usando il PLL interno dovresti arrivare a frequenze di clock molto più alte di 1 MHz per i timers (di cui hai bisogno).

Il modulo PWM sarà sicuramente interfacciato ad alcuni GPIO solamente, ma per commutarne altri non interfacciati a questo devi cambiarne lo stato logico (toggle) nella funzione di interrupt.

Invece di usare le HAL potresti valutare l'uso delle librerie LL.