STM32F4 einfache PWM

[Pief (Gast)]

Ich will nicht lang drumrum reden: PWM soll eine der 4 Onboard LEDs hoch 
und runter-drimmen und das funktioniert nicht. Hier der gesamte Code:

/* Includes */
#include "stm32f4xx.h"

/* Private macro */
/* Private variables */
/* Private function prototypes */
/* Private functions */


void delay()
{
  volatile uint32_t delayCount = 262143;

  while(delayCount > 0)
    delayCount--;
}

void initPWM_LED(void)
{
  TIM_OCInitTypeDef  TIM_OCInitStructure;
  GPIO_InitTypeDef  GPIO_InitStructureTimerPin;
  TIM_TimeBaseInitTypeDef    TIM_TimeBaseStructure;


  //timer and port clock enable
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

  //general port settings
  GPIO_InitStructureTimerPin.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructureTimerPin.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructureTimerPin.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructureTimerPin.GPIO_PuPd = GPIO_PuPd_UP ;

  //set pin 12 to output
  GPIO_InitStructureTimerPin.GPIO_Pin = GPIO_Pin_12;
  GPIO_Init(GPIOD, &GPIO_InitStructureTimerPin);

  //set pin 13 to output
  GPIO_InitStructureTimerPin.GPIO_Pin = GPIO_Pin_13;
  GPIO_Init(GPIOD, &GPIO_InitStructureTimerPin);

  //set pin 14 to output
  GPIO_InitStructureTimerPin.GPIO_Pin = GPIO_Pin_14;
  GPIO_Init(GPIOD, &GPIO_InitStructureTimerPin);

  //set pin 15 to output
  GPIO_InitStructureTimerPin.GPIO_Pin = GPIO_Pin_15;
  GPIO_Init(GPIOD, &GPIO_InitStructureTimerPin);

  //connect TIM4 CH1..5 to PD12..15
  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);

  //timer frequency 1kHz
  uint32_t timer_clk=1000000;
  uint32_t timer_out_clk=1000;

  //timer base configuration
  TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t) ((SystemCoreClock/timer_clk)-1);
  TIM_TimeBaseStructure.TIM_Period = (timer_clk/timer_out_clk);
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

  //timer init
  TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);

  //common PWM config
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

  //special PWM config CH1
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = (timer_clk/timer_out_clk)/1;
  TIM_OC1Init(TIM4, &TIM_OCInitStructure);
  TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);

  //special PWM config CH2
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = (timer_clk/timer_out_clk)/1;
  TIM_OC2Init(TIM4, &TIM_OCInitStructure);
  TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable);

  //special PWM config CH3
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = (timer_clk/timer_out_clk)/1;
  TIM_OC3Init(TIM4, &TIM_OCInitStructure);
  TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable);

  //special PWM config CH4
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = (timer_clk/timer_out_clk)/1;
  TIM_OC4Init(TIM4, &TIM_OCInitStructure);
  TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable);

  // preload timer config
  TIM_ARRPreloadConfig(TIM4, ENABLE);

  // enable timer / counter
  TIM_Cmd(TIM4, ENABLE);
}

int main(void)
{
  initPWM_LED();
  TIM_OCInitTypeDef TIM_OCInitStructure;
  int i;

  //while(!GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0))
  //{;}

  while(1)
  {
    for(i=0;i<1000;i++)
    {
          TIM_Cmd(TIM4, DISABLE);

          TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
          TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
          TIM_OCInitStructure.TIM_Pulse = i;
          TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
          TIM_OC4Init(TIM4, &TIM_OCInitStructure);
          TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable);

          TIM_ARRPreloadConfig(TIM4, ENABLE);
          delay();
    }
  }
}

Ich finde den Fehler nicht, vlt. bin ich betriebsblind vom vielen 
rumprobieren.

Danke

[Niklas G. (erlkoenig)]

Hier
Beitrag "Re: STM32 Servoansteuerung PWM"
hab ich nen Code gepostet zum steuern von Servos über den STM32F4, was 
ja auch per PWM passiert. Damit kann man dann auch LED's dimmen, das 
ggf. noch durch Änderung der Parameter optimieren (Prescaler, Period, 
Pulse)

[Pief (Gast)]

Niklas Gürtler schrieb:
> Hier
> Beitrag "Re: STM32 Servoansteuerung PWM"
> hab ich nen Code gepostet zum steuern von Servos über den STM32F4, was
> ja auch per PWM passiert. Damit kann man dann auch LED's dimmen, das
> ggf. noch durch Änderung der Parameter optimieren (Prescaler, Period,
> Pulse)

Und durch vergleich sehe ich keinen Unterschied?!

[Niklas G. (erlkoenig)]

Dann beschreibe doch mal was da nicht geht...

[Flo (Gast)]

Pief schrieb:
> for(i=0;i<1000;i++)
>     {
>           TIM_Cmd(TIM4, DISABLE);
>
>           TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
>           TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
>           TIM_OCInitStructure.TIM_Pulse = i;
>           TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
>           TIM_OC4Init(TIM4, &TIM_OCInitStructure);
>           TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable);
>
>           TIM_ARRPreloadConfig(TIM4, ENABLE);
>           delay();
>     }

das ist nicht ganz der richtige weg,
bin jetzt nicht gerade im saft,
aber du reinitialiserst ständig diesen pwm

das ist eine timing sache.
soll: im prinziep gibst du dem timer im laufenden betrieb
den neuen wert, ohne die die anderen register neu zu bespielen

abgesehen davon ist das jede menge code für eine pwm steuerung

gib mir mal ne sekunde,
such eben mal den zugriff raus

[Florian G. (Firma: Student) (flogo)]

lass die initialisierung in deiner schleife weg und schreibe stattdessen

TIM4->CCR1 = Deine_Variable;
TIM4->CCR2 = Deine_Variable;
.
.
.

ich weiß auch garnicht ob das so sinnvoll ist,
dass was du machst!

deine pwm braucht mehrere zyklen,
und wenn ich das richtig sehe,
würgst du den schon mitten drin ab

mit dem direktzugriff,
wird die pwm einmal durchgeführt,
und dann wird der nächste wert übernommen,
aber wenn der spaß mehrere zyklen dauert,
und du mit jeden zyklus mit +1 inkrementierst,
kann es sein das dieser eine wesentlich höhere zahl übernimmt

[Pief (Gast)]

Danke für die antworten, aber sorry leute: ICh versteh nur bahnhof

Das mit jedem jedes mal neu initialisieren erscheint mir als einziger 
Weg überhaupt ansatzweise zu funktionieren. Wenn ich nur den 
Pulsbreitenwert einmal beschreibe (ohne for-schleife) tut sich gor nix.

Ich muss mindestens den TIM abschalten und wieder abschalten.

@Flo: Wieso würge ich die PWM ab? Ich hab doch ein fettes delay 
eingebaut.

[Pief (Gast)]

Niklas Gürtler schrieb:
> Hier
> Beitrag "Re: STM32 Servoansteuerung PWM"
> hab ich nen Code gepostet zum steuern von Servos über den STM32F4, was
> ja auch per PWM passiert. Damit kann man dann auch LED's dimmen, das
> ggf. noch durch Änderung der Parameter optimieren (Prescaler, Period,
> Pulse)

Sorry, ich hab zu vorschnell abgewiesen. Ich guck mir deinen Code 
nochmal genauer an und studiere ihn. Danke dafür.

[Niklas G. (erlkoenig)]

Pief schrieb:
> @Flo: Wieso würge ich die PWM ab? Ich hab doch ein fettes delay
> eingebaut.
Bei den 168 MHz die so ein STM32F4 hat ist das delay jetzt gar nicht mal 
sooo lang. Je nachdem wie der Timer eingestellt ist...

[Florian G. (Firma: Student) (flogo)]

das delay selbst hab ich jetzt übersehen,

tut aber nichts zur sache...
stimmt die länge des delay nicht,
haste da ein problem

schau dir mal die pheripherie datasheet mal an,
da steht auch die funktionsweise der register

da siehste dass das hw pwm für sich selbst arbeitet,
da musste selbst nicht manuell neu starten,
und übergibst nur den neuen wert (pulsbreite)
den er beim nächsten zählen übernimmt...

du mischt gerade soft und hardware pwm!!!

deswegen einmal kurz nachlesen!

[Pief (Gast)]

Was ich eigentlich möchte ist die LED dunkel nach hell zu fahren. Das 
ist der SInn der For-Schleife. Ich dachte das geht aus dem Code hervor, 
hat aber jetzt keiner so verstanden, oder?

Ich möchte einfach das Duty Cycle von 0% nach 100% laufen lassen.

[Pief (Gast)]

Ich habe die Main jetzt folgendermaßen abgeändert. so funktioniert es:

int main(void)
{
  initPWM_LED();
  initButtons();

  uint16_t i;

  while(1)
  {
    for (i = 0; i < 300; i++)
    {
      TIM_SetCompare1(TIM4,i);
      TIM_SetCompare2(TIM4,i);
      TIM_SetCompare3(TIM4,i);
      TIM_SetCompare4(TIM4,i);
      delay();
    }
    for (i = 300; i > 0; i--)
    {
      TIM_SetCompare1(TIM4,i);
      TIM_SetCompare2(TIM4,i);
      TIM_SetCompare3(TIM4,i);
      TIM_SetCompare4(TIM4,i);
      delay();
    }
  }
}

Wo liegt denn jetzt der unterschied zwischen:

TIM_SetCompare3(TIM4,i);

und

TIM_Cmd(TIM4, DISABLE);
TIM_OCInitStructure.TIM_Pulse = i;
TIM_OC3Init(TIM4, &TIM_OCInitStructure);
TIM_Cmd(TIM4, ENABLE);

[Florian G. (Firma: Student) (flogo)]

während setcompare (den befehl so kannte ich noch garnicht),
quasi das macht, was ich schon vorhin versucht habe dir zu erklären,
also den wert in das entsprechende register reinschreibt,
und der mc selbsständig darauf zurückgreift, ohne(!) den timer zu 
stoppen

deine intialisierung in der schleife hat zur folge, dass
bei jedem zugriff (!) der timer gestoppt (!)
der wert neu gesetzt wird, und der timer neu gestartet wird,
mit anderen worten, der kommt garnicht zum zählen,
da dieser wieder gestoppt wird um neu beschrieben zu werden

verstehste was ich meine?

[Florian G. (Firma: Student) (flogo)]

btw. statt dem delay kannste auch ein timerinterrupt auslösen lassen,
der den wert um einen erhöhen lässt,
und ins register schreiben lässt.

die main while schleife kann frei bleiben

[Pief (Gast)]

Florian G. schrieb:
> verstehste was ich meine?

Jau danke.


Florian G. schrieb:
> die main while schleife kann frei bleiben

Jau verstehe ich auch, wollts ja nur testen. Irgendwo hier im Forum hab 
ich mir ne funktionierende PWM abgeschaut die das leider genauso macht 
mit dem deinitialisieren, beschreiben, neuinitialisieren. Jeztt hab ich 
wieder was dazu gelernt.

[Florian G. (Firma: Student) (flogo)]

moin kein ding,
vor 3 monaten stand ich genau vor dem selben problem,
deswegen wusste ich auch auf anhieb wo das problem lag ^^

sag mir mal eben mit welcher standart pheripherie library du arbeitest?

[Pief (Gast)]

StdPeriph_Lib_V1.0.0 / 30-September-2011

Content:
    Cortex-M CMSIS V2.1 (release notes)
    CMSIS DSP Software Library V1.0.10  (release notes)
    STM32F4xx CMSIS V1.0.0 (release notes)
    STM32F4xx_StdPeriph_Driver V1.0.0 (release notes)
    STM32F34xx_StdPeriph_Examples V1.0.0 (release notes)
    STM32F4xx_StdPeriph_Templates V1.0.0 (release notes)
    STM32_EVAL Common drivers V5.0.0 (release notes)
    STM3240_41_G_EVAL board drivers V1.0.0 (release notes)

[Pief (Gast)]

Könnte mir noch jemand erklären, was ich konfigurieren muss um einen 
Interrupt mit Frequenz x auslösen zu lassen?

[Flo (Gast)]

da ich gerade auf den sprung bin,
schau dir das nvic register an,
da gibs du an welcher interrupt ausgelöst werden soll,
bei welcher "source"...
aber was meinst du genau mit "frequenz"?

[Gerhard G. (g_g)]

Hallo,

hier mal die initialiesierung und Infos zum Takt von Timer2.

1/Frequenz ist deine Taktrate.


Gruß xmega

[Moritz M. (avrprogger)]

Hallo hier mal ein beispiel

Moritz