STM32F4 und Hallsensoren

[Tobias P. (hubertus)]

Hallo Leute,

ich versuche mit dem STM32F407 die Hallsensoren eines BLDC abzufragen, 
damit ich den dann ansteuern kann. PWM usw. habe ich schon 
implementiert, die läuft auch. Was aber nicht geht, ist die Abfrage der 
Hallsensoren.

Ich möchte das wie folgt tun:
die 3 Hallsensoren werden mit CH1, CH2 und CH3 des Timer 8 verbunden. Da 
gibt es ja diesen XOR-Mode, wo angeblich die 3 Eingangssignale 
XOR-Verknüpft werden. Diesen Mode benutze ich - Code siehe unten.

Der Gedanke dahinter ist, dass IMMER wenn sich an den Hallsensoren was 
ändert, der Timerinterrupt aufgerufen wird. Das funktioniert auch, aber 
der Hallsensor an CH1 wird interessanterweise gar nicht beachtet. Was 
ist das Problem mit diesem Eingang? Ich sehe den Wald vor lauter Bäumen 
nicht mehr, suche schon den ganzen Abend :-)

  RCC_APB2ENR |= BIT_01;
  TIM8_CCER = 0;

  /* configure timer 8 auto-reload buffer */
  TIM8_CR1 = BIT_07;

  /* timer 8 input is xor of ch1, ch2 and ch3 */
  TIM8_CR2 = BIT_07;

  /* enable counter mode */
  TIM8_SMCR = (BIT_06 | BIT_02 | BIT_01 | BIT_00);
  TIM8_CR1 |= BIT_00;

  /* configure the channels 1 to 3 */
  TIM8_CCMR1 = (BIT_08 | BIT_00);
  TIM8_CCMR2 = BIT_00;

  /* enable timer 8 interrupts */
  TIM8_DIER = BIT_06;
  NVIC_ISER1 |= BIT_13;

Bin mal gespannt.

Ach ja, was mich auch interessieren würde:
Die Kommutierung meines BLDC geschieht ja "von Hand", d.h. im 
Timerinterrupt muss ich den gewünschten PWM-Dutycycle abhängig von der 
aktuellen Rotorposition ins richtige Register setzen. Gibt es eine 
Möglichkeit, das zu automatisieren, damit ich nicht bei jeder 
Hallsensoränderung einen Interrupt zu verarbeiten haben? sonst wird ja 
die Interruptlast recht hoch, denke ich.


Mit Gruss
Tobias

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

Tobias Plüss schrieb:
> Das funktioniert auch, aber
> der Hallsensor an CH1 wird interessanterweise gar nicht beachtet.

Zeig mal die Portkonfiguration. Es könnte auch nützlich sein, die 
Pullups an den Halleingängen zu aktivieren.

Tobias Plüss schrieb:
> Die Kommutierung meines BLDC geschieht ja "von Hand", d.h. im
> Timerinterrupt muss ich den gewünschten PWM-Dutycycle abhängig von der
> aktuellen Rotorposition ins richtige Register setzen. Gibt es eine
> Möglichkeit, das zu automatisieren, damit ich nicht bei jeder
> Hallsensoränderung einen Interrupt zu verarbeiten haben? sonst wird ja
> die Interruptlast recht hoch, denke ich.

Nö, das kannste bei einem MC der STM32F4 Leistungsklasse vergessen. Die 
paar Zyklen merkt der MC fast gar nicht. Eine kleine Tabelle mit den 6 
möglichen Zuständen der Sensoren als Index wäre schon so ziemlich das 
Äusserste an Optimierung, aber ein switch..case Konstrukt ist vermutlich 
übersichlicher.
Übrigens muss das alles auch nicht im Timerinterupt geschehen, sondern 
könnte auch ein Pinchange sein. Den Timerinterrupt könntest du dann 
freier für die Geschwindigkeitsregelung und andere regelmässige Aufgaben 
nehmen (PID Regler, ADCs usw. )

[Jo D. (Firma: Jo) (discovery)]

> Gibt es eine
> Möglichkeit, das zu automatisieren

Du könntest einen DMA-Request auslösen, der dann aus einer Tabelle den 
Wert ins Register schiebt. Das geht automatisch. Aber das ist wie 
Matthias sagt nicht nötig.

[Tobias P. (hubertus)]

Hallo,

ok, ich werde heute Abend dann mal meine Portinitialisierung hier noch 
hochladen. Habe meinen Sourcecode sowieso noch ein wenig umgestellt. 
Denn ich möchte nun 2 Motoren ansteuern; für den einen Motor benutze ich 
TIM8, für den anderen TIM1.

Die Hallsensoren schliesse ich an TIM3 und TIM4 an, jeweils mit der 
XOR-Funktion, und aktiviere bei beiden Timern den Trigger-Interrupt. 
Wenn dann an den Hallsensoren was wackelt, dann wird der 
Trigger-Interrupt angesprungen, und der Timer zählt 1 hoch - das ist 
zumindest die Idee.

Kann man so machen, oder?
Ich überlege nur noch grade, ob ich das hochzählen des Timers für irgend 
etwas nützliches noch gebrauchen kann. Speedmessung sollte ja möglich 
sein....

Also, die Pullups sind auf alle Fälle aktiviert, auf dem Oszi sehe ich, 
dass der Eingang tatsächlich auch mal High ist, und wenn man am Motor 
dreht irgendwann mal auf Low springt.

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

Jo discovery schrieb:
> Du könntest einen DMA-Request auslösen, der dann aus einer Tabelle den
> Wert ins Register schiebt.

Hmm, ich muss glatt mal nachschauen, ob der DMA Controller auch ausm 
Flash lesen kann. Bis jetzt hab ich nur RAM und Peripherie mit DMA 
beschickt. Wäre ne nette kleine Möglichkeit, um z.B. Audio Samples auf 
den DAC zu schreiben.

Tobias Plüss schrieb:
> Die Hallsensoren schliesse ich an TIM3 und TIM4 an, jeweils mit der
> XOR-Funktion, und aktiviere bei beiden Timern den Trigger-Interrupt.

Ich hatte für meine BLDC Projekte das mal probiert, aber der Aufwand mit 
den Massen von Timern erschien mir viel zu hoch und kompliziert. 
Mittlerweile hängen die Sensoren schlicht an den untersten 3 Bit eines 
Ports und lösen einen EXTI aus, der sich dann um Kommutierung oder 
Raumzeigersektor kümmert. Das war wesentlich einfacher, als sich durch 
den Timer Dschungel zu wühlen.
Da der PWM Timer sowieso läuft, benutze ich diesen Interrupt für 
Geschwindigkeitsmessung und regelmässige Aufgaben.

[Tobias P. (hubertus)]

Hallo Matthias,

puh, endlich habe ich den Fehler in meinem Code gefunden.

Einer der GPIOs war falsch initialisiert. Nun läuft der Code aber. Ich 
habe zwei BLDCs angeschlossen; die Hallsensoren sind jeweils an Timer 2 
bzw. Timer 4. Mit dem XOR-Mode werden die Timer getaktet, wenn einer der 
Hallsensoren "wackelt", der Timer zählt dann hoch und ein Interrupt wird 
aufgerufen.

Im Interrupt stelle ich den Duty Cycle jeweils richtig ein. Geht jetzt 
alles :-D

bei Interesse kann ich meinen Code hier hoch laden; es ist allerdings 
keine grosse Hexerei, sich durch den Timer-Dschunel zu kämpfen (ich habe 
auch nur relativ einfache Funktionen implementiert, keine "Verkettungen" 
der Timer untereinander usw.)


Eigentlich würde ja jetzt nur noch ein Drehgeber fehlen, dann könnte man 
eine Feldorientierte Regelung implementieren!



Wie misst du den Speed deiner Motoren? Das finde ich immer eine etwas 
schwierige Messung; man muss z.B. einen Counter 1 Sekunde lang oder so 
laufen lassen und die Pulse der Hallsensoren zählen oder irgend sowas. 
Das gefällt mir nicht, schon nur weil es eine ziemliche Totzeit gibt, 
die dann den Regler stört... ich möchte eigentlich später dann man die 
Drehzahlen meiner BLDCs einigermassen gut regeln können; ich möchte vor 
allem im unteren Drehzahlbereich fahren.

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

Tobias Plüss schrieb:
> Eigentlich würde ja jetzt nur noch ein Drehgeber fehlen, dann könnte man
> eine Feldorientierte Regelung implementieren!

Das benötigt keinen Drehgeber, abgesehen davon würde die Zeit um den 
Drehgeber abzufragen (SSI oder EnDat) viel zu viel Zeit benötigen. Ich 
benutze Sinustabellen und resynchronisiere die Pointer mit den 
Hallsensor Events.
Das Prinzip ist einfach und wird in AppNote AVR447 gut besprochen und 
umgesetzt. Bei AVR läuft es mit 3 Timern in einem 8-bitter 
(ATMega88/168...), das Prinzip ist aber leicht umsetzbar auf einen der 
Advanced Timer des STM32 mit 3 seiner 4 CC Register. (Ich nehme Timer8 
auf einem STM32F103).
Am elegantesten alleridngs finde ich dafür allerdings AWEX auf einem 
XMega.

Tobias Plüss schrieb:
> Wie misst du den Speed deiner Motoren? Das finde ich immer eine etwas
> schwierige Messung; man muss z.B. einen Counter 1 Sekunde lang oder so
> laufen lassen und die Pulse der Hallsensoren zählen oder irgend sowas.
> Das gefällt mir nicht, schon nur weil es eine ziemliche Totzeit gibt,
> die dann den Regler stört

Die Geschwindigkeitsmessung fällt bei diesem Prinzip sozusagen ab. Der 
Overflow IRQ des Timers triggert die Sinuserzeugung und inkrementiert 
nebenbei was, unter anderem auch deswegen, um einen Motorstillstand zu 
erkennen. Dieses Inkremetieren wird auch für die 
Rotationsgeschwindigkeit benutzt.

[Tobias P. (hubertus)]

Hallo,

ja also mit Drehgeber wäre es natürlich am bequemsten, da ich dann zu 
jedem Zeitpunkt sofort die exakte Position weiss, und nicht "schätzen" 
muss.

Du hast in deiner Anwendung also tatsächlich eine FOC implementiert? 
sehr interessant!
Wie machst du das beim Starten des Motors, dort kannst du ja noch nicht 
auf die Hallsensoren synchronisieren, weil du ja zu dem Zeitpunkt noch 
nicht weisst, wie schnell der Motor dreht.

Avr447 kenne ich einigermassen; der Witz ist, soweit ich mich erinnere, 
dass man die Pulsdauer der Hallsensoren misst, und dann dazwischen quasi 
mit einer "Software-PLL" interpoliert. Oder so ähnlich, ja?

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

Tobias Plüss schrieb:
> Wie machst du das beim Starten des Motors, dort kannst du ja noch nicht
> auf die Hallsensoren synchronisieren, weil du ja zu dem Zeitpunkt noch
> nicht weisst, wie schnell der Motor dreht.

Meine Anwendung ist aus AVR447 entwickelt. Dort wird der Motor in 
Blockkommutierung gestartet und nach einigen 'richtigen' Sensorwechseln 
auf Sinus umgeschaltet. Die 'Messuhr' für den Abstand zwischen den 
Sensorwechseln läuft aber sofort mit.

Tobias Plüss schrieb:
> der Witz ist, soweit ich mich erinnere,
> dass man die Pulsdauer der Hallsensoren misst, und dann dazwischen quasi
> mit einer "Software-PLL" interpoliert. Oder so ähnlich, ja?

So ähnlich - die Software misst die Zeit zwischen zwei Sensorwechseln 
und interpoliert bei jedem PWM Timerüberlauf aus der 'Uhr' die Position 
in die Sinustabelle. Die absolute Pulsdauer der Sensoren ist dabei 
unwichtig, entscheidend sind nur die Flanken. Ein kompletter Zyklus 
besteht also aus den 6 möglichen Sensorzuständen. Bei Sensorwechsel wird 
der zum Sensormuster passende Sektorabschnitt in der Sinustabelle als 
neuer aktueller Startwert benutzt.
Das ganze funktioniert sehr gut, ist schnell durch die Tabelle und 
leicht portierbar, auch auf andere Motore. Bis jetzt läuft es hier auf 
dem Orginal Mega88, dem XMega A3 und dem STM32F103. Als Motore benutze 
ich hier einen Plattenspieler Pioneer Direct Drive zum Testen und ein 
paar 48V/2000-4000W Radnabenmaschinen.

[Tobias P. (hubertus)]

Hallo Matthias,

ich frage mal so direkt: darf ich mir deinen Code mal anschauen? Es 
würde mich echt interessieren, wie du das mit dem STM32 machst. Wie das 
Prinzip geht, habe ich schon verstanden, aber softwaremässig kriege ich 
es irgendwie nicht so recht gebacken - irgendwie sehe ich den Timer-Wald 
vor lauter Timern nicht mehr so recht ;-)

Ich lasse es jetzt erstmal mit Blockkommutierung und normal PWM laufen, 
da weiss ich schon, dass es funktioniert und mache jetzt gar keine 
grossen Tests. Was aber toll wäre, wenn ich die feldorientierte Regelung 
gebacken bekäme. Ich möchte das gerne mal "zu Fuss" implementieren (mit 
einer fertigen Library ist ja nicht so spassig ;-) ) und daher wäre ein 
Denkanstoss ganz praktisch! Also, darf ich mal gucken? :D

Gruss
Tobias

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

Das ist sehr umfangreich. Insgesamt sind das ca. 100k Sourcecode, 
verteilt auf einige Dateien. Da diese mehr oder weniger zusammenhängen , 
zeige ich mal nur die Timer und EXTI Init und die beiden ISR für Timer 
und EXTI:

/* 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_OCInitStructure.TIM_Pulse = 0x0000;
TIM_OC2Init(TIM1, &TIM_OCInitStructure);
TIM_OCInitStructure.TIM_Pulse = 0x0000;
TIM_OC3Init(TIM1, &TIM_OCInitStructure);
}
/* Setup Hall inputs */
RCC_APB2PeriphClockCmd(HALL_GPIO_CLK | RCC_APB2Periph_AFIO, ENABLE);
GPIO_InitStructure.GPIO_Pin = H1_GPIO_PIN | H2_GPIO_PIN | H3_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(HALL_GPIO_PORT, &GPIO_InitStructure);
/* Setup Hall Interrupt */
/* Connect EXTI0 Line to Hall1 GPIO Pin */

GPIO_EXTILineConfig(HALL_EXTI_PORT_SOURCE, HALL1_EXTI_PIN_SOURCE);
GPIO_EXTILineConfig(HALL_EXTI_PORT_SOURCE, HALL2_EXTI_PIN_SOURCE);
GPIO_EXTILineConfig(HALL_EXTI_PORT_SOURCE, HALL3_EXTI_PIN_SOURCE);

/* Configure Hall EXTI line */

EXTI_InitStructure.EXTI_Line = (HALL1_EXTI_LINE | HALL2_EXTI_LINE | HALL3_EXTI_LINE);
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
EXTI_ClearITPendingBit(HALL1_EXTI_LINE | HALL2_EXTI_LINE | HALL3_EXTI_LINE);
/* Enable and set EXTI0 Interrupt to the lowest priority */
NVIC_InitStructure.NVIC_IRQChannel = HALL1_EXTI_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = HALL2_EXTI_IRQn;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = HALL3_EXTI_IRQn;
NVIC_Init(&NVIC_InitStructure);
}

Und hier die beiden ISRs:

/* return the number of the current hallsensors
 * which should be between 1 and 6
 * values of 0 or 7 mean an error and should set the ERR_HALLSENSOR bit in 'error'
 */
uint16_t GetHall(void) {
volatile uint8_t n = 0;
volatile uint16_t hall;
 //       Delay(HALLDELAY);
        hall = HALL_GPIO_PORT->IDR & HALLMASK;
        while(n<6){
          if (hall == (HALL_GPIO_PORT->IDR & HALLMASK)) {
            n++;
 //           Delay(HALLDELAY);
            }
          else {
            n = 0;
            hall = (HALL_GPIO_PORT->IDR & HALLMASK);
          }
        }
        if ( (hall < 1) | (hall > 6)) hallerrcount++;
         if (hallerrcount > 3 ) error |= ERR_HALLSENSORS;
         halls = hall;   // debug
         return hall;
}
void HallIRQ() {
  EXTI_ClearFlag(EXTI_Line0 | EXTI_Line1 | EXTI_Line2);
volatile uint16_t hall = GetHall();
    // spurious trap - this routine should only be fired if we have a
    // valid sensor change
if (lastHall != hall ) {
  MotorSynchronizedUpdate();
    if (fastFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION) {
        BlockCommutate(GetDesiredDirection(), hall);
       }
    ActualDirectionUpdate(lastHall, hall);
    lastHall = hall;
    }
}
/**
  * @brief  This function handles External line0 interrupt request.
  * @param  None
  * @retval None
  *  Hall Sensor 1 IRQ
  */
void EXTI0_IRQHandler(void)
{
  if(EXTI_GetITStatus(HALL1_EXTI_LINE) != RESET)
  {
    /* Clear the EXTI line pending bit */
    EXTI_ClearITPendingBit(HALL1_EXTI_LINE);
     HallIRQ();
  }
}
/*
*  Hall Sensor 2 IRQ
*/
void EXTI1_IRQHandler(void)
{
  if(EXTI_GetITStatus(HALL2_EXTI_LINE) != RESET)
  {
    /* Clear the EXTI line pending bit */
    EXTI_ClearITPendingBit(HALL2_EXTI_LINE);
    HallIRQ();
  }
}
/*
*  Hall Sensor 3 IRQ
*/
void EXTI2_IRQHandler(void)
{
  if(EXTI_GetITStatus(HALL3_EXTI_LINE) != RESET)
  {
    /* Clear the EXTI line pending bit */
    EXTI_ClearITPendingBit(HALL3_EXTI_LINE);
    HallIRQ();
   }
}
/* the TIM1 Interrupt is fired by an overflow of the main PWM timer
 * it calculates a new Sine Table Pointer and writes the values to the OC registers
 * In Block Commutation it only writes an updated value of amplitudes by calling
 * BlockCommutationDuty()
 * regular tasks include firing the PID controller and reading the ADC.
 */
void TIM1_UP_TIM16_IRQHandler(void){
//uint8_t speedRegTicks = 0;
// microcontroller.net : Clear the IT pending bit before doing any GPIO stuff
TIM_ClearITPendingBit(TIM1,(TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3));
  LED_GPIO_PORT->BSRR = ERROR_LED_PIN;  // debug
    CommutationTicksUpdate();
    if (fastFlags.driveWaveform == WAVEFORM_SINUSOIDAL)
    {
      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);
    }
    else if (fastFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION)
    {
      blockCommutationDuty = amplitude * BLOCK_COMMUTATION_DUTY_MULTIPLIER;
      if (blockCommutationDuty > 255)
      {
        blockCommutationDuty = 255;
      }
      BlockCommutationSetDuty((uint8_t)blockCommutationDuty);
    }

  // regular tasks call the SpeedController
    speedRegTicks++;
      if (speedRegTicks >= SPEED_CONTROLLER_TIME_BASE)
      {
      SpeedController();
           speedRegTicks = 0;
    }
    LED_GPIO_PORT->BRR = ERROR_LED_PIN;
}

Ich weiss, das da jede Menge Dinge drin sind, die für dich keinen Sinn 
ergeben, aber ich darf nicht den gesamten Code posten. Da das ein 
Projekt in Fluss ist, sind da Parameter einstellbar und die 
Fehlerbehandlung alleine sind massig Zeilen, da es um ein 
sicherheitsrelevantes Teil geht.

[Tobias P. (hubertus)]

Hallo Matthias,

vielen Dank für deinen Code!

Meinen habe ich gestern nach langer Bastelei zum Laufen gebracht. Er ist 
wie folgt:

/*============================================================================*/
static void init_pwm(void)
/*------------------------------------------------------------------------------
  Function:
  initialise timer 1 for pwm generation; pwm outputs are pa8, pe11, pa10.
  initialise timer 8 for pwm generation; pwm outputs are pc6, pc7, pc8.
  in:  none
  out: none
==============================================================================*/
{
  duty_right = 0u;
  duty_left = 0u;

  /* enable and reset timer 1 */
  RCC_APB2ENR |= BIT_00;
  TIM1_CCER = 0u;

  /* configure timer 1 auto-reload buffer */
  TIM1_CR1 = BIT_07;

  /* set the autoreload value and the prescaler */
  TIM1_ARR = ARR_VALUE;
  TIM1_PSC = PSC_VALUE;

  /* configure the channels 1 to 3 */
  TIM1_CCMR1 = (BIT_14 | BIT_13 | BIT_11 | BIT_06 | BIT_05 | BIT_03);
  TIM1_CCMR2 = (BIT_06 | BIT_05 | BIT_03);

  /* set all duty cycles to 0 */
  TIM1_CCR1 = 0u;
  TIM1_CCR2 = 0u;
  TIM1_CCR3 = 0u;

  /* force register update */
  TIM1_EGR = BIT_00;

  /* enable timer 1 channels 1 to 3 */
  TIM1_CCER = (BIT_10 | BIT_08 | BIT_06 | BIT_04 | BIT_02 | BIT_00);

  /* set deadtime and enable output */
  TIM1_BDTR = (BIT_15 | PWM_DEADTIME);

  /* start timer 1 */
  TIM1_CR1 |= BIT_00;
} /* end init_pwm */

/*============================================================================*/
static void gpio_init(void)
/*------------------------------------------------------------------------------
  Function:
  initialise all gpio pins.
  in:  none
  out: none
==============================================================================*/
{
  /* enable gpio port a */
  RCC_AHB1ENR |= BIT_00;

  /* switch to alternate function on port a pins */
  GPIOA_MODER |= (BIT_21 | BIT_17 | BIT_15 | BIT_05 | BIT_03 | BIT_01);

  /* enable pullups for the hall sensors */
  GPIOA_PUPDR |= (BIT_04 | BIT_02 | BIT_00);

  /* enable alternate function 1 for port a: timer channels for timer 2 */
  GPIOA_AFRL |= (BIT_00 | BIT_04 | BIT_08);

  /* enable alternate function 1 for port a: timer channels for timer 1 */
  GPIOA_AFRH |= (BIT_00 | BIT_08);

  /* enable alternate function 3 for pa7: timer 8 inverted channel 1 */
  GPIOA_AFRL |= (BIT_29 | BIT_28);

  /* enable gpio port b */
  RCC_AHB1ENR |= BIT_01;

  /* switch to alternate function on port b pins */
  GPIOB_MODER |= (BIT_31 | BIT_29 | BIT_27 | BIT_17 |
                  BIT_15 | BIT_13 | BIT_03 | BIT_01);

  /* enable pullups for the hall sensors */
  GPIOB_PUPDR |= (BIT_16 | BIT_14 | BIT_12);

  /* enable alternate function 2 for port b: timer 4 channels 1 to 3 */
  GPIOB_AFRL |= (BIT_29 | BIT_25);
  GPIOB_AFRH |= BIT_01;

  /* enable alternate function 1 for port b: timer 1 inverted channels 1 to 3 */
  GPIOB_AFRH |= (BIT_28 | BIT_24 | BIT_20);

  /* enable alternate function 3 for port b: timer 8 inverted channels 2 & 3 */
  GPIOB_AFRL |= (BIT_05 | BIT_04 | BIT_01 | BIT_00);

  /* enable gpio port c */
  RCC_AHB1ENR |= BIT_02;

  /* switch to alternate function for port c pins */
  GPIOC_MODER |= (BIT_23 | BIT_21 | BIT_17 | BIT_15 | BIT_13);

  /* enable alternate function 3 - timer 8 channels */
  GPIOC_AFRL |= (BIT_29 | BIT_28 | BIT_25 | BIT_24);
  GPIOC_AFRH |= (BIT_01 | BIT_00);

  /* switch to the alternate function 7 - usart 3 */
  GPIOC_AFRH |= (BIT_14 | BIT_13 | BIT_12 | BIT_10 | BIT_09 | BIT_08);

  /* enable gpio port d */
  RCC_AHB1ENR |= BIT_03;

  /* enable output pin and set it to low */
  GPIOD_MODER |= BIT_30;
  GPIOD_BSRR = BIT_31;

  /* enable gpio port e */
  RCC_AHB1ENR |= BIT_04;

  /* switch to alternate function on port e pin */
  GPIOE_MODER |= BIT_23;

  /* enable alternate function 1 for pin pe11 */
  GPIOE_AFRH |= BIT_12;
} /* end gpio_init */

/*============================================================================*/
static void init_timers(void)
/*------------------------------------------------------------------------------
  Function:
  initialise the timers for the hall sensors
  in:  none
  out: none
==============================================================================*/
{
  /* enable timer 2 and 4 */
  RCC_APB1ENR |= (BIT_02 | BIT_00);

  /* reset timer 2 */
  TIM2_CCER = 0u;

  /* enable autoreload buffer */
  TIM2_CR1 = BIT_07;

  /* timer 2 input is xor of ch1, ch2 and ch3 */
  TIM2_CR2 = BIT_07;

  /* enable counter mode */
  TIM2_SMCR = (BIT_06 | BIT_02 | BIT_01 | BIT_00);

  /* configure the channels 1 to 3 */
  TIM2_CCMR1 = (BIT_08 | BIT_00);
  TIM2_CCMR2 = BIT_00;

  /* enable timer 2 interrupts */
  TIM2_DIER = BIT_06;
  NVIC_ISER0 |= BIT_28;

  /* enable timer 2 */
  TIM2_CR1 |= BIT_00;

  /* reset timer 4 */
  TIM4_CCER = 0u;

  /* enable autoreload buffer */
  TIM4_CR1 = BIT_07;

  /* timer 4 input is xor of ch1, ch2 and ch3 */
  TIM4_CR2 = BIT_07;

  /* enable counter mode */
  TIM4_SMCR = (BIT_06 | BIT_02 | BIT_01 | BIT_00);

  /* configure the channels 1 to 3 */
  TIM4_CCMR1 = (BIT_08 | BIT_00);
  TIM4_CCMR2 = BIT_00;

  /* enable timer 4 interrupts */
  TIM4_DIER = BIT_06;
  NVIC_ISER0 |= BIT_30;

  /* enable timer 4 */
  TIM4_CR1 |= BIT_00;
} /* end init_timers */


/*============================================================================*/
static void timer4_irq(void)
/*------------------------------------------------------------------------------
  Function:
  called by timer 2 interrupts
  in:  none
  out: none
==============================================================================*/
{
  uint32_t hall;

  /* tell the os that interrupts are processed */
  os_irq_enter();

  /* get current state of the hall sensors */
  hall = ((GPIOB_IDR & (BIT_06 | BIT_07 | BIT_08)) >> 6);

  /* set appropriate pins for commutation */
  switch(hall)
  {
    /* hallsensor 1 */
    case (BIT_00):
    {
      /* enable pwm channels 1 and 3 */
//      TIM1_CCER = (BIT_11 | BIT_10 | BIT_09 | BIT_08 | BIT_02 | BIT_00);
      TIM1_CCER = (BIT_10 | BIT_09 | BIT_08 | BIT_03 |  BIT_02 | BIT_00);
      TIM1_CCER |= (BIT_04 | BIT_05);

      /* set duty cycles */
      TIM1_CCR1 = duty_left;
      TIM1_CCR2 = 0u;
      TIM1_CCR3 = duty_left;
    }
    break;

    /* hallsensor 1 and 2 */
    case (BIT_01 | BIT_00):
    {
      /* enable pwm channels 2 and 3 */
//      TIM1_CCER = (BIT_11 | BIT_10 | BIT_09 | BIT_08 | BIT_06 | BIT_04);
      TIM1_CCER = (BIT_10 | BIT_09 | BIT_08 | BIT_07 | BIT_06 | BIT_04);
      TIM1_CCER |= (BIT_01 | BIT_00);

      /* set duty cycles */
      TIM1_CCR1 = 0u;
      TIM1_CCR2 = duty_left;
      TIM1_CCR3 = duty_left;
    }
    break;

    /* hallsensor 2 */
    case (BIT_01):
    {
      /* enable pwm channels 1 and 2 */
//      TIM1_CCER = (BIT_06 | BIT_04 | BIT_03 | BIT_02 | BIT_01 | BIT_00);
      TIM1_CCER = (BIT_07 | BIT_06 | BIT_04 | BIT_02 | BIT_01 | BIT_00);
      TIM1_CCER |= (BIT_09 | BIT_08);

      /* set duty cycles */
      TIM1_CCR1 = duty_left;
      TIM1_CCR2 = duty_left;
      TIM1_CCR3 = 0u;
    }
    break;

    /* hallsensor 2 and 3 */
    case (BIT_02 | BIT_01):
    {
      /* enable pwm channels 1 and 3 */
//      TIM1_CCER = (BIT_10 | BIT_08 | BIT_03 | BIT_02 | BIT_01 | BIT_00);
      TIM1_CCER = (BIT_11 | BIT_10 | BIT_08 | BIT_02 | BIT_01 | BIT_00);
      TIM1_CCER |= (BIT_04 | BIT_05);

      /* set duty cycles */
      TIM1_CCR1 = duty_left;
      TIM1_CCR2 = 0u;
      TIM1_CCR3 = duty_left;
    }
    break;

    /* hallsensor 3 */
    case (BIT_02):
    {
      /* enable pwm channels 2 and 3 */
//      TIM1_CCER = (BIT_10 | BIT_08 | BIT_07 | BIT_06 | BIT_05 | BIT_04);
      TIM1_CCER = (BIT_11 | BIT_10 | BIT_08 | BIT_06 | BIT_05 | BIT_04);
      TIM1_CCER |= (BIT_00 | BIT_01);

      /* set duty cycles */
      TIM1_CCR1 = 0u;
      TIM1_CCR2 = duty_left;
      TIM1_CCR3 = duty_left;
    }
    break;

    /* hallsensor 1 and 3 */
    case (BIT_02 | BIT_00):
    {
      /* enable pwm channels 1 and 2 */
//      TIM1_CCER = (BIT_07 | BIT_06 | BIT_05 | BIT_04 | BIT_02 | BIT_00);
      TIM1_CCER = (BIT_06 | BIT_05 | BIT_04 | BIT_03 | BIT_02 | BIT_00);
      TIM1_CCER |= (BIT_08 | BIT_09);

      /* set duty cycles */
      TIM1_CCR1 = duty_left;
      TIM1_CCR2 = duty_left;
      TIM1_CCR3 = 0u;
    }
    break;

    /* undefined hallsensor state */
    default:
    {
      /* disable all pwm channels */
      TIM1_CCER = 0u;

      /* set all duty cycles to 0 */
      TIM1_CCR1 = 0u;
      TIM1_CCR2 = 0u;
      TIM1_CCR3 = 0u;

      /* this should NEVER happen */
      assert(0);
    }
    break;
  }

  /* clear the interrupt flag */
  TIM4_SR = 0u;

  /* leave interrupt state */
  os_irq_exit();
} /* end timer4_irq */

Zwar dreht der Motor, aber die ganze Geschichte zeigt einige 
Merkwürdigkeiten:

- der Motor dreht schneller, wenn der Duty cycle (Also TIM1_CCRx) klein 
ist. Ist etwas unschön....
- irgendwie scheint es, als ob es regelmässig Kurzschlüsse in meiner 
H-Brücke gäbe, denn der Motor "knattert" zwischendurch, und der 
Stromverbrauch ist bei 50% duty cycle am grössten (?). Auf dem 
Oszilloskop kann ich allerdings nichts erkennen, die Deadtime sieht da 
völlig i.O. aus.

Meine Idee war eigentlich wie folgt:

beim BLDC ist ja immer eine Phase nicht bestromt (gehen wir mal von 
gewöhnlicher Blockkommutierung aus). Ich wollte dann die beiden zu 
bestromenden Phasen wie folgt bestromen: nehmen wir an, Phase 1 und 2 
sollen bestromt werden, dann wollte ich folgendes implementieren:

Phase 1 low side  _____----_____----_____----_____----
Phase 1 high side ---______---______---______---____
Phase 2 low side  ---______---______---______---____
Phase 2 high side _____----_____----_____----_____----

kann man das nicht so machen? wie gesagt wird der Stromverbrauch 
exorbitant, wenn der Duty cycle so um 50% ist. Bei 100% duty Cycle ist 
der Stromverbrauch dann wesentlich kleiner.


Dann noch eine Frage:
du hast ja in deinem Gerät eine Feldorientierte Regelung implementiert. 
Das wäre für meine Anwendung im Prinzip auch das richtige, denn ich muss 
das Drehmoment genau im Griff haben und gut regeln können. Die Sache ist 
die: für FOC musst du ja die Ströme in 2 Phasen kennen. Wie hast du das 
gelöst? Hast du Stromsensoren in die Phasenzuleitungen zu deinem Motor 
eingebaut?

Oder kann ich diese "floatende" Stormmmessung umgehen, indem ich einfach 
immer an der lowside messe?

Ich stehe grad auf dem SChlauch. :-)


Gruss

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

Tobias Plüss schrieb:
> - der Motor dreht schneller, wenn der Duty cycle (Also TIM1_CCRx) klein
> ist. Ist etwas unschön....
> - irgendwie scheint es, als ob es regelmässig Kurzschlüsse in meiner
> H-Brücke gäbe, denn der Motor "knattert" zwischendurch, und der
> Stromverbrauch ist bei 50% duty cycle am grössten (?).

Schau noch mal genau auf die Polarität der OC Ausgänge. Dein Code 
(tschuldigung) ist etwas unübersichtlich, da du praktisch nur 
irgendwelche Bits setzt, die ohne Datenblatt nicht zu verfolgen sind, 
deswegen weiss ich jetzt nicht, ob da alles sauber ist. Das ist einer 
der Gründe, warum ich zur Initialisierung meistens doch auf die Library 
zurückgreife, warum auch nicht. Nur bei zeitkritischen Sachen fummele 
ich dann direkt an den Registern.
Wenn du dir meine Timer Init nochmal anschaust - diese Polaritäten sind 
für 3 Halbbrückentreiber vom Typ IR2110/2112/2113 mit positiver Logik.

Tobias Plüss schrieb:
> Ich wollte dann die beiden zu
> bestromenden Phasen wie folgt bestromen: nehmen wir an, Phase 1 und 2
> sollen bestromt werden, dann wollte ich folgendes implementieren:

Ehrlich gesagt, löse ich das auch über eine Tabelle. Mein EXTI Interrupt 
wird vom Sensor ausgelöst und liest dann den Sensorzustand aller drei 
Sensoren. Dieser Wert dient als Index in eine Tabelle:

// PHASES to position in TIMx_CCER register

#define UH 0x0004
#define UL 0x0001

#define VH 0x0040
#define VL 0x0010

#define WH 0x0400
#define WL 0x0100

#define LOSIDEMASK (UL | VL | WL)
#define HISIDEMASK (UH | VH | WH)
#define PHASEMASK (LOSIDEMASK | HISIDEMASK)
// tables organized for enabling bits in TIMx_CCER
const uint16_t blockCommutationTableForward[8] =
{
  0,               // illegal value
  WH | UL,              // UL, WH
  UH | VL,              // VL, UH
  WH | VL,              // VL, WH
  VH | WL,              // WL, VH
  VH | UL,              // UL, VH
  UH | WL,          // WL, UH
  0               // illegal value
};
/*! \brief Block commutation port direction masks, reverse driving.
 */
const uint16_t blockCommutationTableReverse[8] =
{
      0,
      UH | VL,
      VH | WL,
      UH | WL,
      WH | UL,
      WH | VL,
      VH | UL,
      0
};

Wie du siehst, lasse ich Timer und CC Register einfach weiterlaufen und 
kommutiere über enable/disable der CC Ausgänge. Das ist schweineschnell 
und ich muss gar nicht an den CC Registern rumfummeln, die enthalten 
nach wie vor nur den aktuellen PWM Wert (in allen drei der gleiche bei 
Blockkommutierung). Wert 0 und Wert 7 gibts bei den Sensoren nie, 
deswegen die 0 am Anfang und am Ende der Tabelle. Falls doch mal ein 
solcher Wert auftauchen würde, werden sicherheitshalber alle Phasen 
abgeschaltet.
Eine Tabelle ist für vorwärts und die andere für rückwärts.

Das ganze hat den Vorteil, das ich über ifdefs auch verschiedene Motore 
anwählen kann, jeder mit seiner eigenen Tabelle. Nicht alle Motoren 
benutzen ja das gleiche Schema.

[Tobias P. (hubertus)]

Hallo,

so ich bins nochmal. Ich habe nochmal an meinem Code gebastelt.
Nun ergeben sich die Signale wie im angehängten Oszibild.

Channel A1 ist einer der Hallsensoren.

dann, 0 & 1 sind low und high side Phase 1
      2 & 3 sind low und high side Phase 2
      4 & 5 sind low und high side Phase 3


kann das so stimmen? Der Motor dreht jedenfalls ordentlich, allerdings 
ist die Stromaufnahme ein wenig schlecht; im Bereich mittleren 
PWM-Tastgrades ist sie am höchsten, und das obwohl ich eine Totzeit 
eingebaut habe, siehe 2. Bild.


(Sorry für das Photo, das Oszi kann leider keine Bilder speichern)