Riprodurre audio e musica con STM32 - PCM con la PWM

 

La PCM (Pulse Code Modulation) è una tecnica di codifica digitale utilizzata per rappresentare segnali analogici (come l'audio) sotto forma di dati digitali. È uno dei metodi più comuni per digitalizzare segnali continui e viene utilizzata in molte applicazioni, come telecomunicazioni, registrazione audio digitale e trasmissione multimediale. Può essere definita come una soluzione primordiale per trasmettere audio tramite un microcontrollore.

Il primo step da seguire è quello di convertire un file .wav in un array (vettore) di valori esadecimali in linguaggio c. Il file .wav deve rispettare i seguenti parametri: avere canale audio mono, essere codificato in unsigned 8 bit PCM e avere una frequenza di campionamento tra gli 8 kHz e 16 kHz.

La frequenza di campionamento sarà una scelta a seconda dell’applicazione. Se la qualità dell’audio non interessa particolarmente, 8 kHz possono essere sufficienti. Ovviamente, a parità di bit di codifica, aumentando la frequenza di campionamento, aumenta anche lo spazio occupato in memoria.

Per lo sviluppo di questo progetto, oltre al software STM32CubeIDE, sarà necessario anche Audacity, per l’esportazione del formato audio .wav, e un piccolo programma che converta il file .wav in array PCM.

Esportazione e conversione del file audio

Il file audio scelto deve essere importato all’interno di audacity. Dopo eventuali modifiche a piacimento dell’utente, si procede come segue: File -> Esporta audio... -> Esporta nel computer (figura 1).

Figura 1: pulsante per esportazione sul computer.

Non appena si apre la finestra di esportazione audio, dopo aver impostato il nome del file e il percorso, procedere a settare i parametri nel seguente modo:

1. Formato: WAV (Microsoft);
2. Canali: Mono;
3. Frequenza di: 16000 Hz;
4. Codifica: Unsigned 8-bit PCM.

Cliccare infine su Esporta. Osservare la figura 2.

Figura 2: esportazione del progetto audio.

Dopo aver esportato il file audio in formato .wav, occorre scaricare uno strumento fondamentale, definito WAVC-Converter, recuperato su GitHUB, che ha lo scopo di convertire il file audio .wav a 8 bit in un array compatibile con i file .c, con i segmenti PCM in formato esadecimale.

Usando valori a 8 bit, risulta che ogni valore dell’array PCM è composto di due cifre esadecimali, con un minimo di 0x00 e massimo di 0xFF, in decimale da 0 a 255.

Esportare il file .zip del software in una cartella, preferibilmente sul desktop, dal nome WAVC-Converter. 

Nella medesima cartella, importare il file .wav precedentemente esportato da Audacity (figura 3).

Figura 3: file .wav nella cartella del software WAVC-Converter.

Eseguire il file wavc_converter.exe. Si aprirà una finestra di prompt dei comandi. All'interno dovrà essere digitato il nome del file audio .wav da cui estrare l'array C. Il file deve rigorosamente essere all'interno della stessa directory del software. (Figura 4)

Figura 4: esecuzione del software wavc_converter.exe.

Dopo aver cliccato Enter, usciranno alcune stringhe di descrizione del file audio. Alla fine, premere di nuovo Enter. Figura 5.

Figura 5: conversione del file audio in array .c effettuata.

All'interno della cartella contenente il programma, è ora presente un file .c contenente l'array di valori PCM. Il file .c avrà lo stesso nome del file .wav . Nel caso attuale, audio.c . Osservare la figura 6.

Figura 6: file .c contenente l'array di valori PCM.

Figura 7: array contenuto nel file .c

Scrittura del firmware

Per scrivere il firmware di questa applicazione, è necessario, come sempre, creare un progetto in STM32CubeIDE, e configurare il clock del micro.

1. All'interno dell'interfaccia .ioc, entrare nella sezione Pinout & Configurations -> Timers -> RTC e selezionare la spunta Activate Clock Source, come mostrato in figura 8.

   

   Figura 8: attivazione dell' RTC.

   
   
2. Attivare un qualsiasi timer in modalità PWM. Per semplicità, si è scelto il TIM1, con i seguenti parametri: Clock source = Internal Clock, Channel 1 = PWM Generation CH1, Prescaler = 0, Counter Period = 1000 e, infine, Pulse = 500. Osservare la figura 9.

   

   Figura 9: configurazione del TIM1 in modalità PWM.

   
   
3. Sarà necessario, ai nostri scopi, un timer delay che abbia periodo pari a 1 microsecondo (1 us). Attivare il timer TIM2 con i seguenti parametri: Clock Source = Internal Clock e Prescaler = 84-1. Osservare la figura 10. Per la scelta del prescaler, fare attenzione al datasheet del microcontrollore. La scheda NUCLEO F401RE ha il timer TIM2 situato sul BUS APB1, che ha una frequenza di 84 MHz.

   

   Figura 10: impostazioni del timer TIM2.

   
   

Arrivati a questo punto, può essere generato il codice, tramite l'icona ingranaggio giallo sulla barra superiore (figura 11).

Figura 11: icona ingranaggio giallo

Dopo la generazione del codice, ci si troverà all'interno della pagina di codice main.c
La prima azione da eseguire è la scrittura della funzione delay che sostituirà la già presente HAL_Delay, che ha il difetto di essere bloccante per il sistema.
Dichiarare nella sezione Private Macros, USER CODE BEGIN PM la funzione void delay(int); come mostrato in figura 12.

Figura 12: dichiarazione della funzione delay.

Scendere fino alla sezione USER CODE BEGIN 4 e dichiarare quindi il corpo della funzione delay, come in figura 13.

Figura 13: corpo della funzione delay.

Il codice ricopiabile è il seguente:

void delay(int us){
    __HAL_TIM_SET_COUNTER(&htim2, 0);
    while(__HAL_TIM_GET_COUNTER(&htim2) < us){
        __NOP();
    }
}

Ora occorre proseguire con l'importazione dell'array di valori PCM appena ricavato.
Per semplicità, si può copiare e importare l’array all’interno del file main.c, nella sezione di codice USER CODE BEGIN PV, come mostrato in figura 14.

Figura 14: importazione dell'array.

In seguito alla trascrizione dell'array PCM, è necessario definirne la dimensione, tramite una funzione associata e la primitiva sizeof(...) del linguaggio C. Osservare la figura 15.

Figura 15: calcolo della dimensione dell'array.

Il lettore avrà notato che la dimensione è un uint32_t e non un uint8_t, come definito per l'array.

Il fulcro di questo progetto è modificare il duty cycle della PWM in relazione ai valori della PCM. Il duty cycle di un'onda quadra di tipo PWM può essere calcolato come 

in cui ARR è il valore del registro AutoReload, mentre CCR è il valore del registro CaptureCompare.
Avendo a disposizione 8 bit, il valore massimo che può raggiungere il CCR è pari a 0xFF, ossia 255. Questo significa che il Duty Cycle è pari a 1 quando ARR = CCR. Da questo calcolo, si imposta ARR = 255.

Nella sezione USER CODE BEGIN PM dichiarare la funzione void PlayWave (uint8_t*, uint32_t), la quale avrà il compito di generare l'onda PWM per la riproduzione dell'audio (figura 16).

Figura 16: dichiarazione della funzione PlayWave.

L'array di valori PCM, l'audio, è passato per riferimento!

Nella sezione USER CODE BEGIN 4 viene scritto il corpo della suddetta funzione. Osservare la figura 17. 

Figura 17: corpo della funzione PlayWave.

Codice ricopiabile:

void PlayWave(const uint8_t *audio_data, uint32_t length) {
    HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
    __HAL_TIM_SET_AUTORELOAD(&htim1, 255);
    for (uint32_t i = 0; i < length; i++) {
        __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, audio_data[i]); 
        delay(63);
    }
    HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
}

Questa funzione ha lo scopo di azionare il timer TIM1, canale TIM_CHANNEL_1, in modalità PWM, impostare il registro ARR al valore 255 e iterare l'impostazione del registro CCR al valore definito nell'array di PCM. Conclude con lo Stop della PWM.

Prestare particolare attenzione al valore passato per argomento a delay(...). All'interno deve essere passato il periodo di campionamento in microsecondi. Poichè è stato scelto di campionare il file audio a 16 kHz, con buona approssimazione il periodo di campionamento è pari a 63 us.

In conclusione, all'interno del main attivare il timer TIM2 in modalità base. Eseguire nel loop la funzione PlayWave, passando come argomenti l'array di valori PCM e la sua dimensione. Osservare la figura 18.

Figura 18: ciclo principale del programma.

Il progetto si conclude caricando il firmware nella memoria del microcontrollore. Il risultato sarà la riproduzione dell'audio. Per l'esecuzione, si suggerisce di utilizzare un buzzer o un piccolo altoparlante, che sarà connesso al pin associato al timer TIM_CHANNEL_1.

Nel filmato che segue, ecco cosa accade dopo aver eseguito il caricamento.