stm32f103 3phase-generator

[grundschüler (Gast)]

Ich versuche mich an der Ansteuerung eines FU-ICs mittels Stm32f103C8. 
Anbei die main.c der ersten lauffähigen Version.

Frage zur Deadtime: Diese braucht es beim Umschalten von positiver auf 
negative Halbwelle, damit es keinen Kurzschluss gibt. Bei meiner 
Sinustabelle ist der erste Wert der positiven Halbphase Null. Also von 
48 Werten sind nur 23 größer alws null. Dadurch kann es zwichen den um 
24 Steps versetzten Halbphasen niemals zu einem Kurzschluss kommen.

Kann man die Totzeitberechnung dann einfach weglassen?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

grundschüler schrieb:
> Kann man die Totzeitberechnung dann einfach weglassen?

Warum macht du es dir so schwer? Timer 1 und Timer 8 im STM32F103 sind 
Advanced Timer und haben jeweils 3 PWM Kanäle mit komplementären 
Ausgängen und einem Deadband Unit pro PWM. Ein einziger Timer erzeugt 
ohne Klimmzüge alle 3 Phasen mit einstellbarer Totzeit.

Je nach Gehäuse hat evtl. nur ein Timer der beiden alle Anschlüsse 
herasugeführt, aber das findest du anhand des Datenblattes schnell raus.

[grundschüler (Gast)]

Matthias S. schrieb:
> Warum macht du es dir so schwer?

Gerade einfach hast du es dir mit dem AVR ja auch nicht gemacht. Am 
einfachsten wäre es, deinen code zu nehmen und keine Fragen mehr zu 
stellen. Ich habe da ein Verständnisproblem von dem ich nicht weiß, ob 
es an mir (wahrscheinlich) oder ob es an deinem code (unwahrscheinlich) 
liegt. Ich will halt wissen, wie es funktioniert.

Der Stm-Tim1 ist sehr komplex. Es gibt fertigen code - 
https://arm-stm.blogspot.de/2015/01/3-phase-sinusoidal-pulse-width.html 
- den ich noch nicht ausprobiert habe.

Mit tim2, tim3, + tim4 geht es halt sehr einfach weil genug 
Rechenleistung da ist und weil dise tims einfach zu handeln sind. Also 
mache ich es mir eher so einfach wie möglich.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

grundschüler schrieb:
> Gerade einfach hast du es dir mit dem AVR ja auch nicht gemacht.

So einfach wie möglich. Der kleine AVR8 hat nun mal keinen Timer mit 3 
PWM Kanälen, sondern nur 3 Timer mit je 1 PWM Kanal. Deswegen die 
Klimmzüge beim 3 Phasen Generator.
Die STM32 und XMega hingegen haben fertige Blöcke für den Betrieb von 
Motoren, die man nur benutzen muss.

grundschüler schrieb:
> Also
> mache ich es mir eher so einfach wie möglich.

Nö. Mit einem Advanced Timer brauchst du nur eine ISR, um alles zu 
laden. Mein BLDC Antrieb mit Sinusmodulation auf dem STM32 ist deutlich 
unkomplizierter als der gleiche Antrieb lt. AVR447. Vllt. portiere ich 
den 3-Phasen Generator mal aufs VL Discovery - die liegen hier im Moment 
sowieso nur rum.

[[e-mail] (Gast)]

@grundschüler

Hier ein Ansatz von St, den ich nur mal vorsichtshalber gezogen habe.
http://www.st.com/en/embedded-software/stsw-stm32100.html

Die beschriebene Software habe ich in einen chinesischen Forum gefunden, 
aber noch nicht evaluiert. Sind zwei *.exe. Die würden nach genauer 
Untersuchung verlangen. Deswegen kein Link.

[[e-mail] (Gast)]

Nachtrag.

Man bekommt auch Software von ST. Da muß man erst Java-Script zulassen 
und diverse Lizenzen unterschreiben und Namen angeben.

[grundschüler (Gast)]

Hier mal der Versuch, alles in den advanced timer zu packen 
/Ukmschaltung nur eine Phase. Ich brauche ja 6 um jeweils 60° versetzte 
Halbphasen. Tim1 hat aber nur 3*2+1 channel. Ganz zufrieden bin ich mit 
dem Ergebnis noch nicht. Nach dem Umschalten scheint der abgeschaltete 
Channel nachzuschwingen.

void TIM1_CC_IRQHandler(void)
{
  period= speedmult*255/speeddiv;
  pulse_vh= speedmult*sinetable[step]/speeddiv;
  pulse_uh= speedmult*sinetable[step+8]/speeddiv;
  pulse_wh= speedmult*sinetable[step+16]/speeddiv;
  TIM1->ARR = period;
  TIM1->CCR1 = pulse_uh;
  TIM1->CCR2 = pulse_vh;
  TIM1->CCR3 = pulse_wh;

switch (step)
{
  case (0)://change ch1n to ch1
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_OutputNState= TIM_OutputNState_Disable;
  TIM_OC1Init(TIM1, &TIM_OCInitStructure);
    ;
    break;

  case (48)://change ch1 to ch1n
    TIM1->CCER&=~(1<<0);//CC1E löschen
        TIM1->CCER|=(1<<2);//CC1NE setzen
/**/
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputNState_Disable;
  TIM_OCInitStructure.TIM_OutputNState= TIM_OutputState_Enable;
  TIM_OC1Init(TIM1, &TIM_OCInitStructure);
   ;
    break;

  default:
    ;
    break;
}


zl_tim1++;

step++;
if(step>(47)){
  step=0;
  led1_tog;
  speed_ctrl++;
}

TIM_ClearFlag(TIM1,TIM_FLAG_CC1);
}

[e-mail] schrieb:
> http://www.st.com/en/embedded-software/stsw-stm32100.html

Hab ich installiert, c-code wär mir aber lieber.

[Vincent H. (vinci)]

Ich hab mal einen FU mit einem STM32F405 und dessen TIM1 gebaut. Code 
für den Timer ist hier:
https://gitlab.com/higaski/stm32f405_vfd/blob/master/Src/Periph/pwm.c

Deadtime hab ich damals keine gebraucht, da die in Hardware realisiert 
war. Jeder brauchbare Treiber bietet aber mittlerweile solche Optionen 
an.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Vincent H. schrieb:
> Ich hab mal einen FU mit einem STM32F405 und dessen TIM1 gebaut.

Sieht allerdings mehr nach einem BLDC Antrieb für Motoren mit 
Hallsensoren aus.
Der STM32F1xx hat eine Deadtime Unit:

void UpdateDTI(u8 deadTime){
TIM_BDTRInitTypeDef TIM_BDTRInitStructure;

TIM_BDTRStructInit(&TIM_BDTRInitStructure);
/* Automatic Output enable, Break, dead time and lock configuration*/
TIM_BDTRInitStructure.TIM_OSSRState = TIM_OSSRState_Enable;
TIM_BDTRInitStructure.TIM_OSSIState = TIM_OSSIState_Enable;
TIM_BDTRInitStructure.TIM_LOCKLevel = TIM_LOCKLevel_OFF;
TIM_BDTRInitStructure.TIM_DeadTime = deadTime;
TIM_BDTRInitStructure.TIM_Break = TIM_Break_Disable;
TIM_BDTRInitStructure.TIM_BreakPolarity = TIM_BreakPolarity_High;
TIM_BDTRInitStructure.TIM_AutomaticOutput = TIM_AutomaticOutput_Enable;
TIM_BDTRConfig(TIM1, &TIM_BDTRInitStructure);
}

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Als Hilfe poste ich dir mal die Init von Timer 1 für 3 PWM Kanäle:

/* init the main PWM Timer 1 with 3 channels and dead time insertion
 *
 */
void TimerInit(u8 deadTime) {

RCC_APB2PeriphClockCmd(TIM1_CLK, ENABLE);
/* Initialize basic structures to default */
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_OCStructInit(&TIM_OCInitStructure);
/* Time base configuration */

TIM_TimeBaseStructure.TIM_Prescaler = 256;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = 0x00FF;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;

TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
TIM_UpdateRequestConfig(TIM1, TIM_UpdateSource_Global);
TIM_UpdateDisableConfig(TIM1,DISABLE);

/* Channel 1, 2 and 3 Configuration in PWM mode */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set;
TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Set;

TIM_OCInitStructure.TIM_Pulse = 0x0000;
TIM_OC1Init(TIM1, &TIM_OCInitStructure);
TIM_OC2Init(TIM1, &TIM_OCInitStructure);
TIM_OC3Init(TIM1, &TIM_OCInitStructure);

UpdateDTI(deadTime);
}

Und so initialisiere ich die 6 PWM Ausgänge:

// from setup.h
#define TIM1_CLK                    RCC_APB2Periph_TIM1
// Channel 1
#define PHASE_UL_GPIO_PORT                GPIOA
#define PHASE_UL_GPIO_PIN                 GPIO_Pin_8
// Channel 2
#define PHASE_VL_GPIO_PORT                GPIOA
#define PHASE_VL_GPIO_PIN                 GPIO_Pin_9
// Channel 3
#define PHASE_WL_GPIO_PORT                GPIOA
#define PHASE_WL_GPIO_PIN                 GPIO_Pin_10
// Group configuration
#define LOWSIDE_PINS PHASE_UL_GPIO_PIN | PHASE_VL_GPIO_PIN | PHASE_WL_GPIO_PIN
// Complementary N Outputs
#define PHASE_UH_GPIO_PORT                GPIOB
#define PHASE_UH_GPIO_PIN                 GPIO_Pin_13
//
#define PHASE_VH_GPIO_PORT                GPIOB
#define PHASE_VH_GPIO_PIN                 GPIO_Pin_14
//
#define PHASE_WH_GPIO_PORT                GPIOB
#define PHASE_WH_GPIO_PIN                 GPIO_Pin_15
// Group configuration
#define HIGHSIDE_PINS PHASE_UH_GPIO_PIN | PHASE_VH_GPIO_PIN | PHASE_WH_GPIO_PIN
// define Motor Port properties for the two needed ports
#define PHASE_UH_GPIO_CLK RCC_APB2Periph_GPIOA
#define PHASE_UL_GPIO_CLK RCC_APB2Periph_GPIOB
// end from setup.h 
//*****************************************************
// in main.c
void PortInit(void)
{
GPIO_InitTypeDef  GPIO_InitStructure;
/* Motor Port setup for all six phases */
// Port A
RCC_APB2PeriphClockCmd(PHASE_UH_GPIO_CLK, ENABLE);
// Port B
RCC_APB2PeriphClockCmd(PHASE_UL_GPIO_CLK, ENABLE);
// Highsides are on Port A
GPIO_InitStructure.GPIO_Pin = HIGHSIDE_PINS ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(PHASE_UH_GPIO_PORT, &GPIO_InitStructure);
// Preset to Off
GPIO_ResetBits(PHASE_UH_GPIO_PORT, HIGHSIDE_PINS);
// LowSides are on Port B
GPIO_InitStructure.GPIO_Pin = LOWSIDE_PINS ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(PHASE_UL_GPIO_PORT, &GPIO_InitStructure);
// Preset to Off
GPIO_ResetBits(PHASE_UL_GPIO_PORT,LOWSIDE_PINS) ;
}

Und hier Timer 1 Interrupt Config:

void EnableInterrupts(void){
NVIC_InitTypeDef NVIC_InitStructure;
// Timer interrupt
/* TIM Interrupts enable */
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
/* TIM1 counter enable */
/* Enable and set TIM1 Interrupt to the lowest priority */
/* Enable the TIM1 global Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_TIM16_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
TIM_Cmd(TIM1, ENABLE);
/* Main Output Enable */
//TIM_CtrlPWMOutputs(TIM1, ENABLE);
TIM_ClearITPendingBit(TIM1,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3);
}

Der Timer 1 Interrupt ist bei mir motorspezifisch, aber das Prinzip ist 
das gleiche wie beim AVR Frequenzumrichter. Also inco addieren, Zeiger 
in die Tabelle berechnen, Werte aus der Tabelle skalieren und dann auf 
alle 3 OC Register schicken.

[Vincent H. (vinci)]

Matthias S. schrieb:
> Vincent H. schrieb:
>> Ich hab mal einen FU mit einem STM32F405 und dessen TIM1 gebaut.
>
> Sieht allerdings mehr nach einem BLDC Antrieb für Motoren mit
> Hallsensoren aus.
> Der STM32F1xx hat eine Deadtime Unit:
>

> 
> void UpdateDTI(u8 deadTime){
> TIM_BDTRInitTypeDef TIM_BDTRInitStructure;
> 
> TIM_BDTRStructInit(&TIM_BDTRInitStructure);
> /* Automatic Output enable, Break, dead time and lock configuration*/
> TIM_BDTRInitStructure.TIM_OSSRState = TIM_OSSRState_Enable;
> TIM_BDTRInitStructure.TIM_OSSIState = TIM_OSSIState_Enable;
> TIM_BDTRInitStructure.TIM_LOCKLevel = TIM_LOCKLevel_OFF;
> TIM_BDTRInitStructure.TIM_DeadTime = deadTime;
> TIM_BDTRInitStructure.TIM_Break = TIM_Break_Disable;
> TIM_BDTRInitStructure.TIM_BreakPolarity = TIM_BreakPolarity_High;
> TIM_BDTRInitStructure.TIM_AutomaticOutput = TIM_AutomaticOutput_Enable;
> TIM_BDTRConfig(TIM1, &TIM_BDTRInitStructure);
> }
>

Woran soll man das sehen?
Ich seh keine Initialisierung für Hallsensoren?
Drehgeber hab ich damals glaub ich benutzt, aber die sind woanders 
initialisiert.

Hab mir meinen Code grad nochmal angesehn und die Deadtime ist sogar 
drin... auch wenn meine Treiber die damals wie gesagt inkludiert hatten.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Vincent H. schrieb:
> Woran soll man das sehen?

Du erwähnst die Messung des Motorstroms im Programm und durchläufst die 
für BLDC typischen 6 Sektoren.

[Vincent H. (vinci)]

Matthias S. schrieb:
> Vincent H. schrieb:
>> Woran soll man das sehen?
>
> Du erwähnst die Messung des Motorstroms im Programm und durchläufst die
> für BLDC typischen 6 Sektoren.


Achso, ja der Eindruck täuscht. Die "6 Sektoren" entstehen durch die 
Schaltzeiten der Brücke und bilden die möglichen Zustände aller 6 
Schalter ab. Je nachdem welche Schalter gerade offen bzw. zu sind, wird 
ein anderer Phasenstrom gemessen.

[grundschüler (Gast)]

Vielen Dank für die Beiträge.

Vincent H. schrieb:
> Ich hab mal einen FU mit einem STM32F405 und dessen TIM1 gebaut.

Wenn ichs richtig verstehe, werden die Halbbrücken blockweise - also 
nicht mit einem trägerfrequenzmodulierten Sinus angesteuert?



Matthias S. schrieb:
> Als Hilfe poste ich dir mal die Init von Timer 1 für 3 PWM Kanäle:

Ich würde ja deinen avr-code komplett auf arm umsetzen, wenn ich ihn 
verstehen würde.


Nach meinem Konzept wird die positive Halbbrücke jeder Phase sinusförmig 
mit einem Ausgang angesteuert während der korrespondierende Ausgang der 
negativen Halbbrücke aus ist und keinen Puls generiert. Ich brauche 
jeweils 6 unterschiedliche Werte aus der Sinetable.

Nach deinem code

      InsertDeadband(tempU, &compareHigh, &compareLow);
  OCR0A = compareHigh;
  OCR0B = compareLow;

scheinen beide Halbbrücken gleichzeitig invertiert angesteuert zu 
werden? Du brauchst nur 3Werte aus der Sinetable.


Ist mein Konzept grundsätzlich falsch?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

grundschüler schrieb:
> Nach deinem code
>       InsertDeadband(tempU, &compareHigh, &compareLow);
>   OCR0A = compareHigh;
>   OCR0B = compareLow;
> scheinen beide Halbbrücken gleichzeitig invertiert angesteuert zu
> werden? Du brauchst nur 3Werte aus der Sinetable.

Richtig 3 Werte, 'InsertDeadband()' berechnet die Werte für compareHigh 
und compareLow aus tempU. Das gleiche passiert gleich darauf auch für 
tempV und tempW.
Beim STM32 kannst du darauf verzichten, wenn du das DTI benutzt - das 
Dings fügt von alleine eine Totzeit zwischen den low und High Ausgängen 
ein.
Du musst auch leglich CCR1 schreiben und nicht wie beim AVR OC0A und 
OC0B.

Die Kernroutine im Timer1 Interrupt sieht dann so aus:

      uint8_t tempU, tempV, tempW;
      {
        uint8_t sineTablePtr ;
        AdjustSineTableIndex(sineTableIncrement);
// Add sine table offset to pointer. Must be multiplied by 3, since one 
// value for each phase is stored in the table.
        sineTablePtr =(uint8_t)(sineTableIndex >> 8) * 3;
        tempU = sineTable[sineTablePtr++];
        if (GetDesiredDirection() == DIRECTION_REVERSE)
        {
          tempV = sineTable[sineTablePtr++];
          tempW = sineTable[sineTablePtr];
        }
        else
        {
          tempW = sineTable[sineTablePtr++];
          tempV = sineTable[sineTablePtr];
        }
      }
/* Scale sine modulation values to the current amplitude
 * and poke them into the Compare registers
 */
      TIM_SetCompare1(TIM1,(uint16_t)(amplitude * tempU) >> 8);
      TIM_SetCompare2(TIM1,(uint16_t)(amplitude * tempV) >> 8);
      TIM_SetCompare3(TIM1,(uint16_t)(amplitude * tempW) >> 8);

[grundschüler (Gast)]

Also ist mein 6-werte-Ansatz grundsätzlich falsch?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

grundschüler schrieb:
> Also ist mein 6-werte-Ansatz grundsätzlich falsch?

Er ist unnötig redundant. Sowohl die AVR Software als auch der STM32 
brauchen nur 3 Werte. Der AVR macht daraus mit InsertDeadband() zwei 
Werte (für High und Low) und beim STM32 machts das DTI und die gewählte 
Polarität der PWM Ausgänge aus einem Wert pro Phase.

[grundschüler (Gast)]

Matthias S. schrieb:


Dein code läuft ja bei mir  auf einem m328. Ich werd mir das mal mit 
einem la anschauen, was da an Werten konkret rauskommt. Der 
6-werte-Modus hat halt den Vorteil, dass er den Sinus direkt nachbildet 
und unkompliziert zu programmieren ist.

[Vincent H. (vinci)]

grundschüler schrieb:
> Vielen Dank für die Beiträge.
>
> Vincent H. schrieb:
>> Ich hab mal einen FU mit einem STM32F405 und dessen TIM1 gebaut.
>
> Wenn ichs richtig verstehe, werden die Halbbrücken blockweise - also
> nicht mit einem trägerfrequenzmodulierten Sinus angesteuert?


Nein, der Code verwendet nur keine Sinus-Tabelle, erzeugt aber genauso 
einen Drehvektor. In Zeile 316 steht der Sinus sogar als Funktionsaufruf 
drin. Ein STM32F405 hat mehr als genug Saft um die nötigen Sinus-Werte 
"on demand" zu berechnen. (sogar in double...)

Ob das jetzt sinnvoll ist oder nicht, sei mal dahingestellt.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

grundschüler schrieb:
> Der
> 6-werte-Modus hat halt den Vorteil, dass er den Sinus direkt nachbildet
> und unkompliziert zu programmieren ist.

Ich sehe das nicht so als Vorteil. Denn du bist dann fix auf Totzeit 
etc. festgelegt.

Vincent H. schrieb:
> Ein STM32F405 hat mehr als genug Saft um die nötigen Sinus-Werte
> "on demand" zu berechnen.

Sicher richtig, vor allem, wenn man die Hardware FPU benutzt. Wir 
spielen hier in der Liga STM32F1nn, wo man das leider nicht so hat und 
meist auch nur mit 25MHz taktet.

[grundschüler (Gast)]

Matthias S. schrieb:
> Wir
> spielen hier in der Liga STM32F1nn

Das stm32f426-disco kostet unter 30€. Angesichts des Aufwands - den wir 
ohnehin alle betreiben - sollten 30€ für die bestmögliche mcu kein 
Hindernis sein.

Ich hatte mir für das avr-Projekt extra einen 328pb - mit zusätzlichen 
Timern - zugelegt.


Vincent H. schrieb:
> In Zeile 316 steht der Sinus sogar als Funktionsaufruf
> drin.

Ich werde deinen code auch mal ausprobieren.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

grundschüler schrieb:
> Das stm32f426-disco kostet unter 30€

So etwas gibt es nicht. Es gibt ein F407 Discovery und ein F429 Dicovery 
Board.
http://www.st.com/en/evaluation-tools/stm32-mcu-discovery-kits.html?querycriteria=productId=LN1848
Ausserdem ist es hilfreich, sich vor der Beschaffung mal eine 
Pinbelegung des Boards anzuschauen, denn die meisten Ports sind auf den 
Disco Boards belegt:
http://mikrocontroller.bplaced.net/wordpress/?page_id=46
http://mikrocontroller.bplaced.net/wordpress/?page_id=2848

Ich habe mit beiden Boards und dem VL-Discovery mit STM32F100 
gearbeitet. Für einen Motorantrieb oder FU ist das VL-Disco gut 
geeignet, weil es billig ist und alle Ports verfügbar sind.
http://www.st.com/en/evaluation-tools/stm32vldiscovery.html