Zachodniopomorski Uniwersytet Technologiczny WYDZIAŁ ELEKTRYCZNY Katedra Inżynierii Systemów, Sygnałów i Elektroniki LABORATORIUM Podstawy Programowania Mikroprocesorów i Procesorów DSP Implementacja algorytmów DSP w mikrokontrolerach STM32F3 Opracował: mgr inż. Michał Raczyński 1
Cyfrowe przetwarzanie sygnałów (ang. Digital Signal Processing DSP) jest obecnie stosowane w wielu dziedzinach życia i obejmuje analizę i przetwarzanie sygnałów pochodzących z różnych źródeł. Mamy np. przetwarzanie sygnałów akustycznych (mowy, muzyki, sygnałów wibroakustycznych), czy przetwarzanie obrazów. Niezależnie od źródła, sygnał analogowy jest zamieniany na sygnał cyfrowy czyli ciąg liczb przyjmujących wartości z określonego przedziału liczb całkowitych (im większa jest rozdzielczość przetwornika analogowo-cyfrowego, tym przedział ten jest większy). Następnie zbiór ten może być poddany dowolnym operacjom matematycznym realizowanym za pomocą procesora. W zależności od potrzeb sygnał cyfrowy może być poddany analizie (najpopularniejszym algorytmem jest tutaj szybka transformacja Fouriera ang. Fast Fourier Transform FFT, pozwalająca na zbadanie sygnału pod kątem jego składowych częstotliwościowych) lub przetwarzaniu. Najpopularniejszym rodzajem przetwarzania są filtry cyfrowe o nieskończonej (ang. Infinite Impulse Response - IIR ) oraz skończonej odpowiedzi impulsowej (ang. Finite Impulse Response FIR). Projektowaniu tego typu filtrów poświęcona jest liczna literatura. Niezależnie jednak od zaprojektowanego filtru zawsze przekształca on zbiór próbek wejściowych w zbiór próbek wyjściowych. Szczególnym rodzajem przetwarzania DSP jest przetwarzanie w czasie rzeczywistym. Polega ono na tym, że sygnał analogowy jest zamieniany na postać cyfrową (próbkowany), poddany przetwarzaniu, a następnie zamieniany z powrotem na sygnał analogowy. Cały ten proces przebiega w czasie rzeczywistym, tzn. kolejne próbki wyjściowe muszą być obliczone i podane na wyjście zanim pojawią się kolejne próbki wejściowe. Narzuca to dodatkowe wymaganie na szybkość całego procesu przetwarzania (procesor musi wykonać operacje na bieżącej próbce i wysłać ją na przetwornik cyfrowo-analogowy zanim nadejdzie kolejna próbka). Przetwarzanie w czasie rzeczywistym jest stosowane np. przy różnego rodzaju procesach regulacji (np. prędkości obrotowej czy momentu silnika elektrycznego) czy dodawaniu efektów dźwiękowych (pogłos, echo) do sygnału akustycznego pochodzącego z mikrofonu. Na Rys. 1 przedstawiono tor przetwarzania sygnału akustycznego wykorzystany podczas ćwiczenia laboratoryjnego. Wejściowy analogowy filtr dolnoprzepustowy jest tzw. filtrem antyaliasingowym, który służy do usunięcia z sygnału analogowego wyższych harmonicznych. Zgodnie z założeniem twierdzenia o próbkowaniu częstotliwość próbkowania musi być ponad dwa razy wyższa niż częstotliwość najwyższej harmonicznej obecnej w przetwarzanym sygnale akustycznym. Nieprzestrzeganie tego założenia może skutkować powstaniem tzw. zjawiska aliasingu, które powoduje zniekształcenie odtwarzanego sygnału. Częstotliwość graniczna zastosowanego filtru antyaliasingowego to 3,2kHz. Często po przetworniku cyfrowo-analogowym stosuje się także analogowy filtr dolnoprzepustowy (tzw. rekonstrukcyjny). Wyjściowy wzmacniacz mocy umożliwia wysterowanie niewielkiego głośnika lub słuchawek. Rys. 1. Schemat blokowy toru przetwarzania DSP Przetwornik analogowo-cyfrowy, cyfrowo-analogowy oraz rdzeń wykonujący obliczenia są elementami mikrokontrolera STM32F303RET6. Aby pełniej wykorzystać moc obliczeniową operacje przesyłania danych z przetwornika A/D do pamięci oraz z pamięci do przetwornika D/A są realizowane poprzez układ DMA. Obydwa przetworniki są taktowane za pomocą timera TIM2, za pomocą którego można dobrać częstotliwość próbkowania. Schemat blokowy przetwarzania sygnału wewnątrz mikrokontrolera przedstawiono na rysunku 2. 2
Rys. 2. Tor sygnału w mikrokontrolerze STM32F303RET6 Moduł DMA 1 służy do przesyłania danych z przetwornika A/D do tablicy w pamięci RAM o nazwie BUF_IN natomiast moduł DMA 2 odpowiada za przesyłanie danych z tablicy BUF_OUT do przetwornika D/A. Dane wejściowe zawarte w BUF_IN są przetwarzane programowo za pomocą odpowiedniego algorytmu DSP, a obliczone próbki wyjściowe zapisywane do BUF_OUT. Cały proces jest realizowany w czasie rzeczywistym. Aby uniknąć konfliktu polegającego na tym, że rdzeń będzie próbował uzyskać dostęp do elementu tablicy, który jest aktualnie obsługiwany przez moduł DMA zastosowano prosty algorytm przełączania pomiędzy pierwszą i drugą połową elementów tablicy (jest to schematycznie zaznaczone na Rys. 2). Algorytm zawsze pobiera do przetwarzania próbki z tej połowy tablicy BUF_IN, do której przesyłanie danych przez DMA 1 zostało właśnie zakończone. Podobnie zapisywanie próbek wyjściowych następuje zawsze do tej połowy tablicy BUF_WY, z której przesyłanie danych przez DMA 2 zostało zakończone. Ustalenie która połowa tablicy została właśnie przesłana jest możliwe dzięki uruchomieniu przerwań od modułów DMA, które są zgłaszane odpowiednio po zakończeniu transmisji połowy oraz całej objętości tablicy. Program wykorzystany w laboratorium umożliwia implementację następujących funkcjonalności: 1. przesyłanie sygnału z wejścia na wyjście bez żadnej modyfikacji (w celu sprawdzenia działania poszczególnych bloków); 2. dodanie efektu pogłosu lub echa; 3. filtrowanie sygnału filtrem IIR; Listing programu przedstawiono poniżej: /* Includes */ #include "stm32f3xx.h" #define size 3000 //global variables uint16_t buf_in[size],buf_out[size]; float buf_outf[size]; volatile uint8_t sw1=0,sw2=0, DAC_start=0; // Low pass IIR filter coefficients (fp == 8000Hz) 3
//fg = 500Hz const float b[3] = 0.0299546439,0.0599092878,0.0299546439, a[3] = - 0.0000000000,1.4542466402,-0.5740651488; //fg = 1000 Hz //const float b[3] = 0.0976313874,0.1952627748,0.0976313874, a[3] = - 0.0000000000,0.9428120255,-0.3333376050; //fg = 2000 Hz //const float b[3] = 0.2928943634,0.5857887268,0.2928943634, a[3] = - 0.0000000000,0.0000000487,-0.1715775281; // Low pass IIR filter coefficients (fp == 20000Hz) //fg == 4000Hz //const float b[3] = 0.2065728903,0.4131457806,0.2065728903, a[3] = - 0.0000000000,0.3695288002,-0.1958203614; //fg == 8000Hz //const float b[3] = 0.6389473677,1.2778947353,0.6389473677, a[3] = -0.0000000000,- 1.1429837942,-0.4128056169; void IIR(uint16_t n, uint8_t N, uint8_t M) uint8_t j; float value=0; for(j=0;j<n;j++) if(n<j) value += (float)((*(b+j)) * (float)(*(buf_in+size-j))); else value += (float)((*(b+j)) * (float)(*(buf_in+n-j))); for(j=1;j<m;j++) if(n<j) value += (float)((*(a+j)) * (float)(*(buf_outf+size-j))); else value += (float)((*(a+j)) * (float)(*(buf_outf+n-j))); *(buf_outf+n) = value; *(buf_out+n) = (uint16_t)(*(buf_outf+n)); //RCC & flash latency configuration void RCC_config(void) FLASH->ACR = FLASH_ACR_PRFTBE; /* Flash 2 wait state */ FLASH->ACR &= (uint32_t)((uint32_t)~flash_acr_latency); FLASH->ACR = (uint32_t)flash_acr_latency_1; //SYS_CLK not divided RCC->CFGR = RCC_CFGR_HPRE_DIV1; //AHB RCC->CFGR = RCC_CFGR_PPRE2_DIV1; //APB2 RCC->CFGR = RCC_CFGR_PPRE1_DIV2; //APB1 4
// HSE enable RCC->CR = (RCC_CR_HSEON); //wait till HSE ready while(!(rcc->cr&(rcc_cr_hserdy))); //PLL source HSE - not divided - multiply x9 -> 8 MHz * 9 =72MHz RCC->CFGR2 = (RCC_CFGR2_PREDIV_DIV1); RCC->CFGR = (RCC_CFGR_PLLSRC_HSE_PREDIV); RCC->CFGR = (RCC_CFGR_PLLMUL9); // PLL ENABLE RCC->CR = (RCC_CR_PLLON); //wait till PLL ready while(!(rcc->cr&(rcc_cr_pllrdy))); //select pll as sysclk source RCC->CFGR &= ~(RCC_CFGR_SW); RCC->CFGR = RCC_CFGR_SW_PLL; while ((RCC->CFGR & (uint32_t)rcc_cfgr_sws)!= (uint32_t)0x08); // Timer 2 configuration void TIM2_config(void) RCC->APB1ENR = RCC_APB1ENR_TIM2EN; //fp ==8000 Hz => ARR = 2*(36000000/8000) = 9000 //fp ==20000 Hz => ARR = 2*(36000000/20000) = 3600 TIM2->PSC = 0; TIM2->ARR = 9000; // UPDATE IS SELECTED AS TRGO TIM2->CR2 = TIM_CR2_MMS_1; // interrupt enable TIM2->DIER = TIM_DIER_UIE; TIM2->CR1 = TIM_CR1_CEN; void ADC1_config(void)//adc1 in2 // clock for ADC12 enable - no division // RCC->CFGR2 = (RCC_CFGR2_ADCPRE12_DIV1); // AHB - SOURCE OF ADC CLOCK - NO DIVISION RCC-> AHBENR =RCC_AHBENR_ADC12EN; ADC1_2_COMMON ->CCR = ADC12_CCR_CKMODE_0; ADC1-> CR &= (~ADC_CR_ADVREGEN_1); ADC1-> CR = (ADC_CR_ADVREGEN_0); // wait about 10us for ready of vregulator asm volatile("mov R0, #250\n" "PETLA: \n" "SUB R0,#1\n" "CBZ R0,KONIEC\n" 5
"B PETLA\n" "KONIEC:"); // single ended channel ADC1-> CR &= (~ADC_CR_ADCALDIF); //start calibration procedure ADC1-> CR = (ADC_CR_ADCAL); while((adc1-> CR) & (ADC_CR_ADCAL)); // ch1 selection, length of sequence =1 ADC1 -> SQR1 = ADC_SQR1_SQ1_1; // smp1_1 smp1_0 reset value - 00 -> sampling time =1.5 clk cycle // hardware trigger selected - TIM2 TRGO ADC1->CFGR = (ADC_CFGR_EXTEN_0 ADC_CFGR_EXTSEL_0 ADC_CFGR_EXTSEL_1 ADC_CFGR_EXTSEL_3); //DMA ENABLE, CIRCULAR MODE ADC1->CFGR = (ADC_CFGR_DMAEN) (ADC_CFGR_DMACFG); // overmode is enabled ADC1->CFGR = ADC_CFGR_OVRMOD; // enable adc ADC1-> CR = (ADC_CR_ADEN); // wait until adc will be ready while(!(adc1->isr&(adc_isr_adrd))); // software start conversion ADC1->CR = ADC_CR_ADSTART; void DMA1_config(void)// for ADC1 - ch1 //clock for DMA1 RCC->AHBENR = RCC_AHBENR_DMA1EN; // peripherial address - adc1 dr DMA1_Channel1->CPAR = 0x50000040; // memory adress - buf_in DMA1_Channel1->CMAR = (uint32_t) &buf_in; // number of data size samples DMA1_Channel1->CNDTR = size; // priority is low because is only one channel used - no conflicting situations // direction: from periph. to memory, mem. data size: 16bit, periph. data size: 16 bit, increment.: memory adress, half & full transfer int. enable, channel 1 en DMA1_Channel1->CCR = (DMA_CCR_CIRC) (DMA_CCR_MINC) (DMA_CCR_PSIZE_0) (DMA_CCR_MSIZE_0) (DMA_CCR_HTIE) (DMA_CCR_TCIE) (DMA_CCR_EN); void DMA2_config(void)// for DAC1 - ch1 //clock for DMA2 RCC->AHBENR = RCC_AHBENR_DMA2EN; // peripherial address - dac1 dhr12r1 DMA2_Channel3->CPAR = 0x40007408; // memory adress - buf_out 6
DMA2_Channel3->CMAR = (uint32_t) &buf_out; // number of data size samples DMA2_Channel3->CNDTR = size; // priority is low because there is only one channel used - no conflicting situations // direction: from mem. to per, mem. data size: 16bit, periph. data size: 16 bit, increment.: memory adress, half & full transfer int. enable, channel 3 en DMA2_Channel3->CCR = (DMA_CCR_DIR) (DMA_CCR_CIRC) (DMA_CCR_MINC) (DMA_CCR_PSIZE_0) (DMA_CCR_MSIZE_0) (DMA_CCR_HTIE) (DMA_CCR_TCIE) (DMA_CCR_EN); void DAC1_config(void)//dac1 out1 // dac1 clock enable RCC-> APB1ENR =RCC_APB1ENR_DAC1EN; //dac1 ch1 enable DAC1-> CR = DAC_CR_EN1; asm volatile("mov R0, #500\n" "PETLA2: \n\t" "SUB R0,#1\n\t" "CBZ R0,KONIEC2\n\t" "B PETLA2\n\t" "KONIEC2:"); //output buffer enable - boff1 = 0 (reset value) //trigger enable, tim2 trigger selection, DMA enable DAC1-> CR &= (~DAC_CR_BOFF1); DAC1-> CR = DAC_CR_TEN1 DAC_CR_TSEL1_2 DAC_CR_DMAEN1; void TIM2_IRQHandler(void) TIM2->SR &= (~TIM_SR_UIF); GPIOB->ODR ^=(GPIO_ODR_5); void DMA1_Channel1_IRQHandler(void) if(((dma1->isr)&(dma_isr_htif1))) // GPIOB->ODR ^= (GPIO_ODR_6); sw1 = 1; DMA1->IFCR = (DMA_IFCR_CHTIF1); if(((dma1->isr)&(dma_isr_tcif1))) sw1=2; GPIOB->ODR ^= (GPIO_ODR_5); DMA1->IFCR = (DMA_IFCR_CTCIF1); if(dac_start==0) DAC_start = 1; 7
void DMA2_Channel3_IRQHandler(void) if(((dma2->isr)&(dma_isr_htif3))) GPIOB->ODR ^= (GPIO_ODR_6); sw2=1; DMA2->IFCR = (DMA_IFCR_CHTIF3); if(((dma2->isr)&(dma_isr_tcif3))) // GPIOB->ODR ^= (GPIO_ODR_5); sw2=2; DMA2->IFCR = (DMA_IFCR_CTCIF3); /** **=========================================================================== ** ** Abstract: main program ** **=========================================================================== */ int main(void) RCC_config(); NVIC_EnableIRQ(TIM2_IRQn); NVIC_EnableIRQ(DMA1_Channel1_IRQn); NVIC_EnableIRQ(DMA2_Channel3_IRQn); RCC->AHBENR = RCC_AHBENR_GPIOBEN; GPIOB->MODER = (GPIO_MODER_MODER6_0 GPIO_MODER_MODER5_0); DMA1_config(); DMA2_config(); ADC1_config(); TIM2_config(); while (1) if((sw1==1 && sw2==1) (sw1==1 && DAC_start==0)) sw1 = 0; sw2 = 0; for(uint16_t i = 0; i<(size/2); i++) //IIR(i,3,3); //buf_out[i] = buf_in[i]+buf_in[i+(size/2)]>>1; buf_out[i] = buf_in[i]; else if((sw1==2 && sw2==2) (sw1==2 && DAC_start==0)) 8
sw1 = 0; sw2 = 0; for(uint16_t i = (size/2); i<size; i++) //IIR(i,3,3); //buf_out[i] = buf_in[i]+buf_in[i-(size/2)]>>1; buf_out[i] = buf_in[i]; if(dac_start == 1) DAC1_config(); DAC_start =2; return 0; Najważniejsze elementy programu które można modyfikować: - definicja size -określa ilość elementów w tablicach BUF_IN i BUF_OUT - zawartość rejestru ARR odpowiada za częstotliwość próbkowania. Wartość częstotliwości próbkowania można obliczyć ze wzoru: ARR = 2 f clk f s, gdzie f clk, oznacza częstotliwość taktowania timera 2, czyli 36 MHz, a f s żądaną częstotliwość próbkowania. - współczynniki filtrów IIR (stała const float b[3] oraz const float a[3]) odkomentowując odpowiednią linijkę (zawsze jedną) otrzymujemy realizację filtru IIR dolnoprzepustowego o różnych częstotliwościach granicznych; Aby zrealizować funkcjonalność 1. należy: -odkomentować linijki: buf_out[i] = buf_in[i]; (ich numery to 335 i 350); -skompilować i uruchomić program; Należy przetestować jakość przetwarzanego dźwięku dla różnych częstotliwości próbkowania oraz przy obecności oraz pominięciu filtru antyaliasingowego) Aby zrealizować funkcjonalność 2. należy: -zakomentować linijki: buf_out[i] = buf_in[i]; (ich numery to 335 i 350) -odkomentować linijki: buf_out[i] = buf_in[i]+buf_in[i+(size/2)]>>1; (ich numery to 334 i 349) 9
Należy przetestować jakość przetwarzanego dźwięku dla różnych częstotliwości próbkowania oraz różnych wielkości buforów. Aby zrealizować funkcjonalność 3. należy: -zakomentować linijki: buf_out[i] = buf_in[i]+buf_in[i+(size/2)]>>1; -odkomentować linijki: IIR(i,3,3); (ich numery to 333 i 348) - wybrać żądany filtr odkomentowując odpowiednią linijkę oraz ustalić właściwą częstotliwość graniczną. Należy przetestować jakość przetwarzanego dźwięku dla różnych częstotliwości granicznych filtru. 10