ATNEL tech-forum

Re: [STM32F4] PWM

2013-12-05T20:10:10+01:00

Kontynuując wątek timerów...

[syntax=c]void TIM2_Config(void){
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
/* TIM1 Periph clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

/* Time base configuration 10kHz, 0,1ms*10000 = 1s 25us */
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = 250000; //
TIM_TimeBaseStructure.TIM_Prescaler = ( (SystemCoreClock / 2) / 1000000) - 1;
TIM_TimeBaseStructure.TIM_ClockDivision = 0; ///
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;

// CH1
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Timing;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 25; // 1s
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
TIM_OC3Init(TIM2, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Disable);
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM2, ENABLE);

// Włączenie przerwania od porównania w kanale 1
TIM_ITConfig(TIM2, TIM_IT_CC3, ENABLE);
}
void TIM2_Down_IRQHandler(void){
if( TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET ){
// Czyszczenie flagi przerwania
TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
GPIO_WriteBit( GPIOB, GPIO_Pin_10, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_10) ) );
}
}[/syntax]

Mam ustawiony TIM2 na zliczanie w dół. Potrzebuję odliczyć czas, gdzie przerwaniem będzie odpowiednia wartość na przetworniku ADC, więc pewnie będę musiał to jeszcze jakoś zmodyfikować. No, ale jak odczytać wartość na której timer przestał zliczać? Chyba, że źle to kombinuje?

// edit

Próbowałem odczytać wartość licznika funkcją
[syntax=c]TIM_GetCounter(TIM2);[/syntax]

No i chyba otrzymuję to czego potrzebuję (sprawdziłem w trybie krokowym), tylko jest mały problem. Przy tych ustawieniach timer liczy bez przerwy, więc nie wiem ile razy doszedł do maksymalnej wartości. W jaki sposób go zatrzymać, aby odliczał jeden raz? Co prawda przy odpowiednim ustawieniu częstotliwości nie będzie mnie interesowało ile razy będzie liczył od nowa bo zmieszczę się w 1 cyklu, ale w fazie testowej chciał bym widzieć że jest max i coś trzeba poprawić.

Statystyki: Napisane przez karol901 — 5 gru 2013, o 20:10

Re: [STM32F4] PWM

2013-12-03T23:31:15+01:00

nio ale załapałeś jak to liczyć .....
i o to chodziło

Statystyki: Napisane przez SunRiver — 3 gru 2013, o 23:31

Re: [STM32F4] PWM

2013-12-03T22:49:11+01:00

Ok
Rozumiem, że dokładnie tak, oznacza 21kHz. No i właśnie o to mi chodziło.

Czyli
( (SystemCoreClock /2) / 40000000) - 1 dostanę 40kHz

No a Period określa mi do jakiej wartości zliczy. Więc dla Twojego przykładu:
Częstotliwość 21kHz
Czas trwania jednego okresu ok 476us (T1)
Więc gdybym ustawił wypełnienie na 10 to stan wysoki będzie trwał 10 * (476us/665) = 7us

Dobrze kombinuje?

// edit

Rozpędziłem się z zerami. Miało być
( (SystemCoreClock /2) / 40000) - 1

więc u Ciebie w MHz.

Statystyki: Napisane przez karol901 — 3 gru 2013, o 22:49

Re: [STM32F4] PWM

2013-12-03T22:38:11+01:00

dokładnie tak

Statystyki: Napisane przez SunRiver — 3 gru 2013, o 22:38

Re: [STM32F4] PWM

2013-12-03T22:29:19+01:00

No dobra, Preskaler jest ustawiony na 168MHz / 2 / 21kHz czyli = 4000

Tylko tak jak wcześniej pisałem. Żebyśmy się dobrze zrozumieli.

W Twoim przykładzie T1 to jest 21kHz, czy 21kHz/665? Mi tylko o to chodzi.
Przeglądałem sporo przykładów i próbowałem przeliczać ręcznie, ale nie do końca to "czuję".

Statystyki: Napisane przez karol901 — 3 gru 2013, o 22:29

Re: [STM32F4] PWM

2013-12-03T22:15:14+01:00

popatrz w przykładzie w na wiersz 35 .....

teraz już chyba widzisz , a łatwiej było na żywym przykładzie

Statystyki: Napisane przez SunRiver — 3 gru 2013, o 22:15

Re: [STM32F4] PWM

2013-12-03T22:12:42+01:00

Dzięki za przykład, tylko mi chodzi o samo obliczenie częstotliwości. Czy to co napisałem jest dobrze, czy źle to rozumiem?

Statystyki: Napisane przez karol901 — 3 gru 2013, o 22:12

Re: [STM32F4] PWM

2013-12-03T08:30:34+01:00

[syntax=c]int main(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;

// Konfiguracja TIMERA
GPIO_InitTypeDef GPIO_InitStructure;

// Włączenie zegara dla TIM4
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);

// DIODA
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
GPIO_Init(GPIOD, &GPIO_InitStructure);

GPIO_PinAFConfig(GPIOD, GPIO_PinSource12, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource13, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_TIM4);

// Ustawienia PWM

// Preskaler
PrescalerValue = (uint16_t) ((SystemCoreClock /2) / 21000000) - 1;

// Ustawienia bazowe Timera

TIM_TimeBaseStructure.TIM_Period = 665;
TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);

// PWM1 Mode ustawienie dla Kanału 1
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

TIM_OC1Init(TIM4, &TIM_OCInitStructure);

TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);

// PWM1 Mode ustawienie dla Kanału 2
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0;

TIM_OC2Init(TIM4, &TIM_OCInitStructure);

TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable);

// PWM1 Mode ustawienie dla Kanału 3
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0;

TIM_OC3Init(TIM4, &TIM_OCInitStructure);

TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable);

// PWM1 Mode ustawienie dla Kanału 4

TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0;

TIM_OC4Init(TIM4, &TIM_OCInitStructure);

TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable);

TIM_ARRPreloadConfig(TIM4, ENABLE);

// TIM4 włączenie ...................
TIM_Cmd(TIM4, ENABLE);

// -- DEMO ---------------------------------------------------------------------

int jasnosc = 0;

while(1)
{
jasnosc++;

// Ustawienia poziomów jasnosci
TIM4->CCR3 = 333 - (jasnosc + 0) % 333;
TIM4->CCR4 = 333 - (jasnosc + 166/2) % 333;
TIM4->CCR1 = 333 - (jasnosc + 333/2) % 333;
TIM4->CCR2 = 333 - (jasnosc + 499/2) % 333;

// ------- DELAYE
for(i=0;i<10000;i++);
for(i=0;i<10000;i++);
for(i=0;i<10000;i++);
}
}[/syntax]

Statystyki: Napisane przez SunRiver — 3 gru 2013, o 08:30

[STM32F4] PWM

2013-12-02T23:36:48+01:00

Witam, mam nadzieję że piszę w dobrym dziale (chyba jedyny o ARM?)

Mam problem z PWM. Przeglądałem już nie jeden przykład, ale jakoś nie mogę poprawnie obliczyć częstotliwości (przynajmniej tak mi się wydaje).

[syntax=c]void RCC_Config(void){
// Zmienna opisująca rezultat uruchomienie HSE
ErrorStatus HSEStartUpStatus;

// Reset ustawień RCC
RCC_DeInit();

// Włącz HSE
RCC_HSEConfig(RCC_HSE_ON);

// Odczekaj na gotowoć HSE
HSEStartUpStatus = RCC_WaitForHSEStartUp();

if( HSEStartUpStatus == SUCCESS ){
// Ustaw zwłokę dla pamięci FLASH
// Zależnie od taktowania rdzenia
// Voltage range (2,7 - 3,6V)
// @arg FLASH_Latency_0: FLASH Zero Latency cycle 0 - 30MHz
// @arg FLASH_Latency_1: FLASH One Latency cycle 30 - 60MHz
// @arg FLASH_Latency_2: FLASH Two Latency cycles 60 - 90MHz
// @arg FLASH_Latency_3: FLASH Three Latency cycles90 - 120MHz
// @arg FLASH_Latency_4: FLASH Four Latency cycles 120 - 150MHz
// @arg FLASH_Latency_5: FLASH Five Latency cycles 120 - 168MHz
// @arg FLASH_Latency_6: FLASH Six Latency cyclesNA
// @arg FLASH_Latency_7: FLASH Seven Latency cyclesNA
FLASH_PrefetchBufferCmd(ENABLE);
FLASH_SetLatency(FLASH_Latency_5);

// HCLK=SYSCLK
RCC_HCLKConfig(RCC_SYSCLK_Div1);

// PCLK2 = HCLK/2 MAX 84MHz
RCC_PCLK2Config(RCC_HCLK_Div2);

// PCLK1 = HCLK/4MAX42MHz
RCC_PCLK1Config(RCC_HCLK_Div4);

// Ustaw PLLCLK PLLM = 8, PLLN = 336, PLLP = 2, PLLQ = 7
// PLLCLK = (HSE * (PLLN/PLLM))/PLLP = 168MHz (MAX 168MHz)
// USB OTG FS, SDIO, RNG clock output = PLLCLK / PLLQ (MAX 48MHz)
RCC_PLLConfig(RCC_PLLSource_HSE, 8, 336, 2, 7);

// Wlacz PLL
RCC_PLLCmd(ENABLE);

// Odczekaj na poprawne uruchomienie PLL
while( RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET );

// Ustaw PLL jako źródło sygnału zegarowego
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

// Odczekaj az PLL będzie sygnałem zegarowym systemu
// 0x00: HSI used as system clock
// 0x04: HSE used as system clock
// 0x08: PLL used as system clock
while( RCC_GetSYSCLKSource() != 0x08 );

// Konfiguracja peryferiów (jezeli potrzebne)

// Włącz taktowanie portów
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC3, ENABLE);
}
}
void TIM4_Config(void){
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;

/* TIM4 Periph clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);

/* Time base configuration */
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = PeriodValue;
TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);

/* PWM1 Mode configuration: Channel2 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR2_Val;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;

TIM_OC1Init(TIM4, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM4, ENABLE);

/* TIM4 enable counter */
TIM_Cmd(TIM4, ENABLE);
}[/syntax]

No i teraz pytanie czy dobrze liczę?

Prescaler = ( (SystemCoreClock / 2) / 40000) - 1 = ( (168MHz/2) / 40kHz ) - 1 = 2100-1

Czyli prescaler ustawiony na 2099 daje mi częstotliwość timera 40kHz? Czyli już teraz otrzymuje okres PWM 40kHz?

Czy okres PWM ustawiam dopiero w Period i np. Period = (10 - 1) da mi okres 4kHz?

Na prawdę już zgłupiałem i prosze o pomoc.

Pozdrawiam
Karol

Statystyki: Napisane przez karol901 — 2 gru 2013, o 23:36