ATNEL tech-forum

Re: STM2F4 sposób działania przerwania od timera

2018-06-15T15:16:00+01:00

Próbowałem różnych rozwiązań i zdecydowanie najwięcej korzyści przyniosła zmiana typu danych na float. Przy FIR udało mi się uzyskać 50. rząd dla szybkości próbkowania 44100 Hz. Co prawda dla IIR to tylko 12. rząd, ale może wystarczy.

Statystyki: Napisane przez radek04 — 15 cze 2018, o 15:16

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T20:06:42+01:00

radek04 napisał(a):

Mam w projekcie folder CMSIS (używam SW4STM32), ale nie ma w nim przykładów. Gdzie je mogę znaleźć?
W przerwaniu mogę wywoływać funkcję static inline?

Najlepiej ściągnij CubeMX i gdy wygenerujesz jakiś projekt do System Workbench to zostaną pobrane paczki dla STM32F4.
W katalogu użytkownika znajdziesz taką ścieżkę:
STM32Cube\Repository\STM32Cube_FW_F4_V1.18.0\Drivers\CMSIS
Nr biblioteki może się różnić.

W środku będzie pełna biblioteka DSP_lib. Opis biblioteki, w jęz. angielskim, już w tym wątku podsyłałem.
Static inline możesz wywoływać w przerwaniu, bo czemu by nie?

Statystyki: Napisane przez Zealota — 12 cze 2018, o 20:06

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T15:50:41+01:00

Popatrz jak się tego typu filtrowanie robi na innych prockach np DSPIC, może coś wykorzystasz a może zmienisz procka?

Statystyki: Napisane przez micky — 12 cze 2018, o 15:50

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T12:34:26+01:00

Mam w projekcie folder CMSIS (używam SW4STM32), ale nie ma w nim przykładów. Gdzie je mogę znaleźć?
W przerwaniu mogę wywoływać funkcję static inline?

Statystyki: Napisane przez radek04 — 12 cze 2018, o 12:34

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T12:26:45+01:00

radek04 napisał(a):

Jeżeli rząd jest ograniczony do np 20, to przygotowanie 11 "rozpisanych" funkcji (załóżmy powyżej 9 rzędu, które to załóżmy już są problematyczne ) to nie będzie problem jeśli masz sporo pamięci FLASH.
Jeśli podejrzysz kody CMSIS to zauważysz, że są tam tablice stałych o wielkości nawet do 8192 słów, czy też "floatów"
To są właśnie metody na przyśpieszanie kodu poprze eliminacje skoków.
Oczywiście najlepiej jak zrobisz sobie testy i pomierzysz czasy, czy faktycznie będziesz miał zysk.

radek04 napisał(a):

Biblioteka CMSIS też chyba nie przejdzie z powodu narzucenia, by kod filtru był "widoczny".
Najbardziej mnie zainteresowała funkcja wspomagania sprzętowego. Pozostałe rady też spróbuje zastosować. Niestety do piątku jestem poza domem, ale postaram się w miarę możliwości coś poprawić.

Nic nie szkodzi, żebyś sobie podejrzał funkcje do filtrów w CMSIS, może sam wpadniesz na dodatkowe optymalizacje.

Statystyki: Napisane przez Zealota — 12 cze 2018, o 12:26

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T12:28:03+01:00

Świetne rady. Co do rozpisania pętli (o ile dobrze to rozumiem), to raczej się nie uda, bo program ma być "elastyczny" i przystosowany do uzycia dowolnego (acz ograniczonego co do wielkości) rzędu.
Biblioteka CMSIS też chyba nie przejdzie z powodu narzucenia, by kod filtru był "widoczny".
Najbardziej mnie zainteresowała funkcja wspomagania sprzętowego. Pozostałe rady też spróbuje zastosować. Niestety do piątku jestem poza domem, ale postaram się w miarę możliwości coś poprawić.

Edit: Wspomaganie sprzętowe mam włączone.

Statystyki: Napisane przez radek04 — 12 cze 2018, o 12:10

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T10:42:46+01:00

No to teraz sporo się wyjaśniło.
Nie mam niestety doświadczenia w budowaniu filtrów cyfrowych, może poza prostymi "średnimi", ale można trochę podywagować o Twoim rozwiązaniu.
Jak już wyliczałem, dla próbkowania 44100 Hz należy zbierać sample co 22 us, czyli masz mniej więcej tyle czasu na zebranie danych i obliczenia.
Oczywiście to wszystko przy założeniu, że procesor nic innego nie robi. Spójrzmy na obsługę przerwania:
[syntax=c]void TIM5_IRQHandler() {
if (TIM_GetITStatus(TIM5, TIM_IT_Update) == SET) {
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);
//kod przerwania:
ADC_in=ADC_GetConversionValue(ADC1); // odczyt wejscia ADC
probki[0]=(double)ADC_in;
acc=0; // zerowanie akumulatora
for (i=0; i acc+=h[i]*probki[i]; // i dodawania w filtrze
}
DAC_Out=(uint)acc;
DAC_SetChannel1Data (DAC_Align_12b_R,DAC_Out ); // wyslanie do DAC
for (i=rzad; i>0; i--) {
probki[i]=probki[i-1]; // przesuniecie probek w pamieci
}
GPIO_ToggleBits(GPIOA, GPIO_Pin_8);//testy
}
}[/syntax]
Można spróbować kilku optymalizacji.
1. Usunięcie typu double. Procki STM32 nie są zoptymalizowane do tego typu, czy faktycznie potrzebujesz tak dużego zakresu do swoich obliczeń? Może uint32_t wystarczy, a może float32_t? O tym drugim nieco niżej.

2. Używasz pętli, można spróbować rozwinąć pętle, szczególnie te duże wartości 10 i więcej, można by rozpisać do prostych poleceń, tak by procesor nie tracił czasu na skoki. Wielkość kodu wzrośnie, a można zaoszczędzić trochę czasu procesora.
Można stworzyć funkcje static inline z rozwinięciami, zależne od rzędu filtru.

3. Nic nie piszesz o optymalizacjach, które zastosowałeś.
Czy próbowałeś używać bibliotek matematycznych dostarczanych z CMSIS?
Czy włączasz obsługę sprzętową zmiennoprzecinkową, możesz o tym poczytać tutaj:
https://forum.sunduino.pl/viewtopic.php?f=9&t=59
Jeśli włączysz obsługę FPU, to jest szansa, że operacje na float32_t przyśpieszą.

4. Może w ogóle zainteresuj się CMSIS, masz tam obsługę filtrów cyfrowych zoptymalizowaną pod STM32:
https://developer.arm.com/embedded/cmsis
Sekcja:
CMSIS-DSP: Fast implementation of digital signal processing
Lepiej tego pewnie nie napiszesz (a kto tutaj napisze ), niestety to podejście wymaga studiowania tematu.
Ja to już troszkę liznąłem, ale nie na tyle żeby wiele podpowiedzieć.

Mogę napisać dodatkowo, że biblioteka jest obszerna, optymalizacje są zależne od wybranej precyzji (8, 16, 32 bitowej).
Mamy tam szereg podstawowych, zoptymalizowanych funkcji matematyczny jak sinus, średnia, tranformata Fouriera, filtry cyfrowe itp.

Statystyki: Napisane przez Zealota — 12 cze 2018, o 10:42

Re: STM2F4 sposób działania przerwania od timera

2018-06-12T06:46:27+01:00

Masz rację. Założenie jest takie, by filtr działał na bieżąco "w czasie rzeczywistym". Ale jeśli z pewnym niewielkim opóźnieniem także uda się uzyskać sygnał ciągły bez utraty żadnego fragmentu, to też będzie w porządku.
Ale chyba tak się nie da, prawda?

Program ma pokazywać działanie filtru. Na oscyloskopie do jednego kanału podany jest sygnał wejściowych, a do drugiego wyjściowy - albo identyczny z wejściowym, albo tłumiony(częściowo, lub całkowicie). Zastosowanie bardziej edukacyjne, niż praktyczne.

Statystyki: Napisane przez radek04 — 12 cze 2018, o 06:46

Re: STM2F4 sposób działania przerwania od timera

2018-06-10T20:59:04+01:00

radek04 napisał(a):

Myślicie, że powinienem użyć DMA dla pojedynczego odczytu? A może jakoś zoptymalizować inne operacje? Podobno zamiast przesuwania elementów tablicy, można wykorzystać wskaźniki, ale nie do końca wiem jak.

A może napisz po prostu co właściwie ten program ma robić, bo wydaje mi się, że nie do końca wiemy.
Pisałeś o filtrze cyfrowym, ale z tego co rozumiem to po każdym pomiarze z ADC już chcesz od razu coś przeliczać i od razu wyrzucać do DACa. Wg mnie tak się tego nie powinno robić. Pisałem już o tym, zbierasz porcję danych, zaczynasz przeliczać, w czasie przeliczania zbierasz kolejną porcję danych.
Wygląda na to jakbyś chciał zrobić coś w stylu korektora dźwiękowego o bardzo niskim opóźnieniu.

Statystyki: Napisane przez Zealota — 10 cze 2018, o 20:59

Re: STM2F4 sposób działania przerwania od timera

2018-06-10T06:23:22+01:00

Statystyki: Napisane przez radek04 — 10 cze 2018, o 06:23

Re: STM2F4 sposób działania przerwania od timera

2018-06-09T07:08:26+01:00

Wykonuję tylko 1 pomiar, przetwarzanie i wysłanie na DAC w każdym przerwaniu. Wydaje mi się, że sporo czasu może zajmować przesuwanie elementów tablicy.

Statystyki: Napisane przez radek04 — 9 cze 2018, o 07:08

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T22:04:38+01:00

Ile robisz próbek poprzez ADC? Jeśli kilka to faktycznie nie ma sensu użyć DMA, ale jeśli jest ich kilkaset, to należy użyć DMA.
Dla 512 próbek i częstotliwości próbkowania 44100 Hz musisz robić cały pomiar przez 512 * 22 us = 11 ms, zapełniając bufor aż po ostatnią próbkę. Ilość próbek jest zdefiniowana w rejestrze kontrolera DMA. Nie ma sensu aby co 22 us wchodzić w przerwanie i coś tam mnożyć. Lepiej mnożyć przez te 11 ms zbierając próbki już do następnych przeliczeń. Dlatego należy użyć DMA.
Pomiar co 22 us oczywiście wyzwalany jest przez timer, a włączone DMA pozwala zdjąć procesor z konieczności kopiowania danych z rejestru ADC do pamięci RAM.
Warto przeglądnąć to:
https://forbot.pl/blog/kurs-stm32-f4-5- ... io-id13099

Co prawda to w HALu, ale wydaje mi się że sporo musisz nadrobić. Szybkie przejście z HAla na STD nie powinno sprawić kłopotu.

Może zacząć od tego:
https://embedds.com/multichannel-adc-us ... -on-stm32/

Statystyki: Napisane przez Zealota — 8 cze 2018, o 22:04

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T21:20:50+01:00

Czyli do odczytu ADC powinienem użyć DMA, tak? Ale jeśli czegoś nie pomyliłem, to odczyt zajmuje chyba kilkanaście cykli zegara (nie wiem ile ich zapis), więc niewiele zaoszczędzę, a potrzebuję 2x większej szybkości wszystkich operacji.

Statystyki: Napisane przez radek04 — 8 cze 2018, o 21:20

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T21:06:06+01:00

W transferach danych bez udziału procka.

Statystyki: Napisane przez micky — 8 cze 2018, o 21:06

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T21:13:28+01:00

Co do kodu to przyznaję się, że był pisany przez dwóch ludzi i składany z mniejszych fragmentów, stąd te powtórzenia. Jeśli chodzi o SPL, to długa historia. Powoli muszę kończyć projekt i nie bardzo mam czas na rewolucyjne zmiany.
Obliczenia muszą wykonywać się pomiędzy pomiarami i wystawiać DAC na bieżąco. Nie robiłem nigdy DMA. W czym ono dokładnie pomoże?

Statystyki: Napisane przez radek04 — 8 cze 2018, o 20:59

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T18:52:19+01:00

Zealota napisał(a):

Na rejestrach bylaby to jedna linijka.

z std to też jedna linijka .. a nawet jej połowa ...

Tymczasem kod powyższy jest przekombinowany , i pozbawiony logiki ...
zegar wystarczy 1 raz włączyć dla urządzeń nie trzeba robić funkcji i podprogramów ... co zbędnie komplikuje czytanie kodu go zaciemnia
po co kolejne włączanie zegarów w konfiguracji LCD ??

skoro używasz SPI do LCD to nie możesz zdefiniować pinów ??

ale dobra ... bo zaraz mnie spece od rejestrów zlinczują ... że wytykam błędy ...

(jak nie wiesz jak co uruchomić podglądnij sobie w choćby przykładach od STM -- to nie boli )

Statystyki: Napisane przez SunRiver — 8 cze 2018, o 18:52

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T18:20:24+01:00

Wg mnie popełniasz tutaj spory błąd w założeniach, tzn nie używasz DMA do zbierania próbek, stąd pewnie problemy z wydajnością.
Zaleta użycia DMA byłaby tutaj taka, że w momencie przeliczania, mnożenia itp, możesz już zbierać próbki do następnych działań, bez straty czasu procesora. Przeliczanie nie wymaga ścisłych zależności czasowych, może być przerywane innymi zdarzeniami, natomiast zbieranie próbek to i owszem. W F3 masz jeszcze sporo dostępnych kanałów DMA. Druga sprawa, ale już bardziej indywidualna, osobista, to ten bagaż w postaci bibliotek

Z mało istotnych błędów, to niepotrzebnie dwa razy włączasz zegar dla ADC1, ale to takie czepianie się tylko
Dziwnie też dla mnie wygląda konfiguracja zegara dla portów, też jakby dwa razy to włączane, ale z innych funkcji.
Nie znam niestety STD Periph, więc nie wiem, może to poprawne jest. Na rejestrach bylaby to jedna linijka.
[syntax=c]RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN | RCC_AHB1ENR_GPIOBEN |RCC_AHB1ENR_GPIOCEN |RCC_AHB1ENR_GPIODEN;[/syntax]

Statystyki: Napisane przez Zealota — 8 cze 2018, o 18:20

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T16:09:10+01:00

Zostawiłem w przerwaniu tylko sterowanie pinem i faktycznie udaje się uzyskać większe szybkości (ok 700kHz).

Jest to dla mnie wystarczające, więc problemem chyba jest sam kod występujący w przerwaniu:
[syntax=c]void TIM5_IRQHandler()
{

if (TIM_GetITStatus(TIM5, TIM_IT_Update) == SET)
{
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);
//kod przerwania:
ADC_in=ADC_GetConversionValue(ADC1); // odczyt wejscia ADC
probki[0]=(double)ADC_in;
acc=0; // zerowanie akumulatora
for (i=0; i {
acc+=h[i]*probki[i];// i dodawania w filtrze
}
DAC_Out=(uint)acc;
DAC_SetChannel1Data (DAC_Align_12b_R,DAC_Out ); // wyslanie do DAC
for (i=rzad; i>0; i--)
{
probki[i]=probki[i-1]; // przesuniecie probek w pamieci
}
GPIO_ToggleBits(GPIOA, GPIO_Pin_8);//testy
}
}[/syntax]

W razie czego wrzucam konfigurację wszystkich używanych modułów:
[syntax=c]void konfiguracjaZegarow()
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIOAEN, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIOCEN, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
}
void konfiguracjaGPIO()
{
GPIO_InitTypeDef gpio;

//PIN PA8 - do testów tylko
gpio.GPIO_Pin = GPIO_Pin_8;//do oscyloskopu
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio.GPIO_Speed = GPIO_Speed_100MHz;
//Initialize pins
GPIO_Init(GPIOA, &gpio);

}
void konfiguracjaUART()
{
/* Set alternate functions */
GPIO_InitTypeDef gpio;
GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);

/* Init GPIO pins */
//UART
GPIO_StructInit(&gpio);
gpio.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_PuPd = GPIO_PuPd_UP;
gpio.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOA, &gpio);

/* Configure UART setup */
USART_InitTypeDef uart;
USART_StructInit(&uart);
uart.USART_BaudRate = 115200;
uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
uart.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
uart.USART_Parity = USART_Parity_No;
uart.USART_StopBits = USART_StopBits_1;
uart.USART_WordLength = USART_WordLength_8b;
USART_Init(USART2, &uart);
USART_Cmd(USART2, ENABLE);
}
void konfiguracjaADC()
{
//Konfiguracja ADC
ADC_InitTypeDef ADC_Init_Structure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_DeInit();
ADC_StructInit(&ADC_Init_Structure);
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Prescaler = PRESCALER;//zdefiniowane 2,4,6,8
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;//5-20*/
ADC_CommonInit(&ADC_CommonInitStructure);
ADC_Init_Structure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_Init_Structure.ADC_Resolution = ADC_Resolution_12b;
ADC_Init_Structure.ADC_ContinuousConvMode = ENABLE;
ADC_Init_Structure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
ADC_Init_Structure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
ADC_Init_Structure.ADC_NbrOfConversion = 1;
ADC_Init_Structure.ADC_ScanConvMode = DISABLE;
ADC_Init(ADC1, &ADC_Init_Structure);
ADC_RegularChannelConfig(ADC1,ADC_Channel_0,1,CYCLES);//zdefiniowane 3,15,28,56,84,112,144,480
ADC_Cmd(ADC1,ENABLE);

GPIO_InitTypeDef gpio;
//Konfiguracja pinu analogowego
//Kanal 0 podlaczony do PA0
gpio.GPIO_Pin = GPIO_Pin_0;
gpio.GPIO_Mode = GPIO_Mode_AN;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &gpio);
}
void konfiguracjaLCD()
{
GPIO_InitTypeDef gpio;
SPI_InitTypeDef SPIInit;

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

//Definicja funkcji alternatywnych dla pinów MOSI oraz CLK
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource3, GPIO_AF_SPI1); //podłączenie do PB3(D3)

GPIO_StructInit(&gpio);
gpio.GPIO_Pin = GPIO_Pin_7; //MOSI
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &gpio);

gpio.GPIO_Pin = GPIO_Pin_3;// SCK
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &gpio);

gpio.GPIO_Pin = GPIO_Pin_6; // MISO
gpio.GPIO_Mode = GPIO_Mode_IN;
GPIO_Init(GPIOA, &gpio);

gpio.GPIO_Pin = LCD_DC|LCD_CE|LCD_RST;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
GPIO_Init(GPIOB, &gpio);
GPIO_SetBits(GPIOB, LCD_CE|LCD_RST);

SPI_StructInit(&SPIInit);
SPIInit.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPIInit.SPI_Mode = SPI_Mode_Master;
SPIInit.SPI_CPOL = SPI_CPOL_Low;
SPIInit.SPI_CPHA = SPI_CPHA_1Edge;
SPIInit.SPI_NSS = SPI_NSS_Soft;
SPIInit.SPI_DataSize = SPI_DataSize_8b;
SPIInit.SPI_FirstBit = SPI_FirstBit_MSB;
SPIInit.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
SPI1->CR1 &= ~SPI_CR1_SPE;
SPI_Init(SPI1, &SPIInit);
SPI_Cmd(SPI1, ENABLE);
}

void konfiguracjaPrzerwania()
{
TIM_TimeBaseInitTypeDef tim;
NVIC_InitTypeDef nvic;

TIM_TimeBaseStructInit(&tim);
tim.TIM_CounterMode = TIM_CounterMode_Up;
tim.TIM_Prescaler = 2 - 1; //16bit -> max 65535 10000 => 100*10^6/10*10^3 = 10kHz (100us)
//tim.TIM_Period = 1134 - 1;//16bit -> max 65535 44100Hz
tim.TIM_Period = 2 - 1;
TIM_TimeBaseInit(TIM5, &tim);
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);
TIM_UpdateRequestConfig(TIM5, TIM_UpdateSource_Regular);
TIM_ITConfig(TIM5, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM5, ENABLE);

nvic.NVIC_IRQChannel = TIM5_IRQn;
nvic.NVIC_IRQChannelPreemptionPriority = 0;
nvic.NVIC_IRQChannelSubPriority = 0;
nvic.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&nvic);
}

void konfiguracjaDAC()
{
// konfiguracja timera
TIM_TimeBaseInitTypeDef TIM6_TimeBase;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);
TIM_TimeBaseStructInit(&TIM6_TimeBase);
TIM6_TimeBase.TIM_Period = 0xFFFFFFFF;//(uint16_t)TIM_PERIOD;
TIM6_TimeBase.TIM_Prescaler = 0;
TIM6_TimeBase.TIM_ClockDivision = 0;
TIM6_TimeBase.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM6, &TIM6_TimeBase);
TIM_SelectOutputTrigger(TIM6, TIM_TRGOSource_Update);
TIM_Cmd(TIM6, ENABLE);

// konfiguracja DAC
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
DAC_InitTypeDef DAC_INIT;
DAC_INIT.DAC_Trigger= DAC_Trigger_None;
DAC_INIT.DAC_WaveGeneration = DAC_WaveGeneration_None;
DAC_INIT.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
DAC_Init(DAC_Channel_1, &DAC_INIT);
DAC_Cmd(DAC_Channel_1, ENABLE);
DAC_DMACmd(DAC_Channel_1, ENABLE);
}[/syntax]

Statystyki: Napisane przez radek04 — 8 cze 2018, o 16:09

Re: STM2F4 sposób działania przerwania od timera

2018-06-08T08:41:03+01:00

radek04 napisał(a):

A może to szybkość zmian stanu pinu jest ograniczona (wychodzi mi ok. 25kHz)?

Takie prędkości to uzyskujesz bez żadnego problemu na AVRze. Więc na pewno na STMie musisz coś źle ustawiać.
Jak masz ustawiony sygnały zegarowe?
Daj trochę więcej informacji o kodzie (szczególnie inicjalizacji) oraz przerwaniu, to może coś Ci podpowiemy
A najlepiej obetnij kod tylko do tego przerwania i sterowania pinem. I sprawdź czy nadal nie działa. Jak tak, to wrzuć na forum a na pewno ktoś Ci pomoże.

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 8 cze 2018, o 08:41

Re: STM2F4 sposób działania przerwania od timera

2018-06-07T20:12:22+01:00

Robię filtry cyfrowe i w przerwaniu wykonuję mnożenia, dodawania i przesuwanie wartości w tablicy. Chciałbym uzyskać fs=44100Hz dla różnych (niewielkich) rzędów filtrów. Ale okazuje się, że już przy ok. 10. rzędzie FIR mam nieprawidłowe wartości.
Sprawdzam działanie przerwania zmieniając stan pinu, który badam oscyloskopem. I okazuje się, że częstotliwość zmian jest ograniczona i od pewnego momentu niezależna od ustawień przerwania. Chodzi mi o to, że gdy już uzyskam maksymalną częstotliwość, to dalsze zmniejszanie tim.TIM_Period nie powoduje zmian tej częstotliwości.
Myślałem, że jeśli kolejne przerwanie wystąpi przed wystawieniem wartości na pinie, to nic się nie będzie działo, bo zacznie się kolejne przerwanie, a dopiero na jego końcu mam zmianę stanu bitu. Dlaczego tak się dzieje? Czyżby gdzieś była zapamiętywana komenda do wystawienia stanu wysokiego lub niskiego i po prostu jest wykonywana z opóźnieniem? A może to szybkość zmian stanu pinu jest ograniczona (wychodzi mi ok. 25kHz)?

Statystyki: Napisane przez radek04 — 7 cze 2018, o 20:12

Re: STM2F4 sposób działania przerwania od timera

2018-06-07T07:31:28+01:00

dambo napisał(a):

odliczanie dzieje się natychmiast - w kodzie przerwania jedynie czyścisz flagę, która informuje, że wystąpił event.
Przerwania powinny się zazwyczaj wykonywać bardzo szybko, nie powinno się ich blokować jakimś dużym kawałkiem kodu.

To bardzo ogólna zasada stosowana tam gdzie nie można ustawiać priorytetów przerwań i wywłaszczeń, np w programowaniu AVR.
Ponieważ piszemy w wątku o STM32 to w wypadku tychże procków najczęściej nie ma zastosowania.
Nawet wręcz przeciwnie, można spotkać zalecenia mówiące, żeby w ogóle pisać w przerwaniach, z pominięciem pętli w main.
Sam zrobiłem już kilka projektów na STM32 i wydaje mi się, że zalecenia te są całkiem sensowne.
Szczególnie przydatne jest tutaj pojęcie wywłaszczenia przerwań.

Statystyki: Napisane przez Zealota — 7 cze 2018, o 07:31

Re: STM2F4 sposób działania przerwania od timera

2018-06-06T21:13:25+01:00

Czyli raczej nie mam sytuacji, w której nie zdąży się wykonać kod, ale jeszcze dokładnie to sprawdzę.

Statystyki: Napisane przez radek04 — 6 cze 2018, o 21:13

STM2F4 sposób działania przerwania od timera

2018-06-06T09:56:00+01:00

Mam pytanie o działanie przerwania.
Mając kod przerwania postaci:
[syntax=c]void TIM5_IRQHandler()
{

if (TIM_GetITStatus(TIM5, TIM_IT_Update) == SET)
{
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);
//kod przerwania:
//moje operacje
//koniec kodu przerwania
}
}[/syntax]kolejne odliczanie timera zaczyna się od momentu wystąpienia poprzedniego przerwania (od miejsca TIM_ClearITPendingBit(TIM5, TIM_IT_Update)), czy od momentu zakończenia wykonywania kodu przerwania ("koniec kodu przerwania")? Co się dzieje w przypadku, kiedy "moje operacje" zajmują więcej czasu, niż odstęp pomiędzy kolejnymi przerwaniami? A może linia TIM_ClearITPendingBit(TIM5, TIM_IT_Update) powinna być na końcu?

Statystyki: Napisane przez radek04 — 6 cze 2018, o 09:56