STM32L1 - 400Hz gleichger. Sinus bei 16MHz erzeugen

[Niklas B. (niklas90)]

Hallo,

in einer Schaltung soll zwecks anspruchsvoller Leistungsregelung ein 
STM32L1 zum Einsatz kommen. Der Stromverbrauch soll dabei möglichst 
niedrig sein. Es sollen in Echtzeit mehrere logische und ein analoger 
Pegel aufgenommen werden. Aus diesen Informationen wird dann ein neuer 
Pegel berechnet, welcher mit einem gleichgerichteten Sinussignal bei 
400Hz ausgegeben wird.
Wir haben bereits eine Steuerung auf rein analoger Basis für die 
Schaltung entworfen, aber die ist halt nur in gewissen Grenzen/Maßen 
funktionell.



Ich habe nun das Problem, dass der L1 irgendwie rumzickt...

Die Initialisierung der Clock(s) bereitet mir Schwierigkeiten - z.b. ist 
die HSI bei mir nur 16MHz - zumindest behauptet dass 
RCC_GetClocksFreq(&...). Andererseits kommt ein sehr komischer Fehler - 
No source available for "0x......" - wenn ich versuche die PLL mit der 
HSI zu füttern. Voltage scaling range ist 1, also beste Performance.

Das ich (noch) keinen externen Quarz in den freien Platz auf dem 
Discovery eingelötet habe, kann ich auch nicht die HSE benutzen, 
allerdings ist auch Genauigkeit weniger das Problem, das Signal soll bei 
jeder Halbwelle mit Hilfe der logischen Pegel neu synchronisiert werden.

Im Moment wird noch nichts verrechnet oder gesteuert, ich probiere nur 
ein vernünftiges, gleichgerichtetes Sinussignal zu erzeugen.
Ich habe zwei Ansätze ausprobiert: DAC und PWM mit einfachem RC-Filter.

*!!!*
Beide Methoden haben das Problem, dass bei 400Hz die Sinushalbwellen 
nicht mehr symmetrisch aussehen und das Signal einen Offset (ca.300mV) 
kriegt.
*!!!*

Beim PWM liegt dass an dem RC-Filter, beim DAC an dem Puffer des L1. 
Letzteren kann man per Software disablen, nur dann sieht das Signal nach 
gar nix mehr aus, völlig unbrauchbar, riesen Offset und kaum Amplitude. 
Wieso? Der Ausgang hängt an einem Oszi mit 1MOhm Eingang. Ein Widerstand 
mit 10kOhm parallel bringt kaum (eig gar nichts) etwas.

Wenn man nach der Signalform ausgeht, gewinnt der DAC, die Unsymmetrie 
ist recht klein im Vergleich zur PWM, außerdem ist die Signalform 
deutlich glatter.
Das Signal der PWM könnte imho gewinnen wenn man die PWM schneller 
machen könnte, aber irgendwie ist die schon am Anschlag (ich komm mit 
den Clocks nicht wirklich zurecht) und die Auflösung ist schon so 
niedrig wie möglich gehalten um noch vernünftige Abstufungen zu 
bekommen.



Hier mal der Quellcode bis jetzt:

// includes
#include <stddef.h>
#include <stdlib.h>
#include "stm32l1xx.h"
#include "halfSinus.h"

// defines
#define VREF 2920 // VREF+ (mV), nearly VDD

// variables
volatile uint16_t amplitude;

// function prototypes
void DAC_Voltage(uint8_t channel, uint16_t mV);
uint16_t ADC_Voltage(uint8_t channel);
void InitPeriph();
void Delay(uint32_t c) {
  while(c--);
}

// main program
int main() {

   SystemInit();

   //PWR_VoltageScalingConfig(PWR_VoltageScaling_Range1); // selects best performance; also set in SystemInit()

   // we can't use HSE because no quarz soldered in place
   /*RCC_HSEConfig(RCC_HSE_ON);
   while(!RCC_GetFlagStatus(RCC_FLAG_HSERDY));
   RCC_PLLConfig(RCC_PLLSource_HSE, RCC_PLLMul_12, RCC_PLLDiv_3);
   RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
   while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_PLL);*/

   // use HSI instead
   RCC_HSICmd(ENABLE);
   while(!RCC_GetFlagStatus(RCC_FLAG_HSIRDY));
   // HSI can't be used as source for PLL for some reason
   RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);
   while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_HSI);

   RCC_ClocksTypeDef clock;
   RCC_GetClocksFreq(&clock); // get current clockspeed -> 16MHz it says

   InitPeriph();

   amplitude = 2000;

   while(1) {
     // just play around with ADC: light up green LED when swiping on touchpad
     if (ADC_Voltage(14) > 1100) {
       GPIO_WriteBit(GPIOB, GPIO_Pin_7, Bit_SET);
     } else {
       GPIO_WriteBit(GPIOB, GPIO_Pin_7, Bit_RESET);
     }
     Delay(1000);
     DAC_Voltage(2, ADC_Voltage(2)); // digitalize input voltage and output on other pin, useful for calibrating VREF
     GPIO_ToggleBits(GPIOB, GPIO_Pin_6);
   }
}

// timer interrupt handler
void TIM4_IRQHandler() {
  static uint8_t i = 0;

  if (TIM_GetITStatus(TIM4, TIM_IT_Update)) { // period overflow
    // clear interrupt trigger
    TIM_ClearITPendingBit(TIM4, TIM_IT_Update);

    TIM3->CCR3 = halfSin[i]*511/4095;
    //TIM9->CCR1 = halfSin[i]*511/4095;
    DAC_SetChannel1Data(DAC_Align_12b_R, halfSin[i]*amplitude/VREF);
    if ((i+=2) >= 99) i = 0;
  }
}


// functions
void DAC_Voltage(uint8_t channel, uint16_t mV) {
  if (channel == 1) DAC_SetChannel1Data(DAC_Align_12b_R, mV*4059/VREF);
  if (channel == 2) DAC_SetChannel2Data(DAC_Align_12b_R, mV*4059/VREF);
}

uint16_t ADC_Voltage(uint8_t channel) {
  ADC_RegularChannelConfig(ADC1, channel, 1, ADC_SampleTime_4Cycles);
  ADC_SoftwareStartConv(ADC1);
  while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
  return ADC_GetConversionValue(ADC1)*VREF/4059;
}

void InitPeriph() {
  // turn on clock for LEDs
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
  // initialize LEDs on board
  GPIO_InitTypeDef gpioInitStruct;
  gpioInitStruct.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_6; // green led: PB7 , blue led: PB6
  gpioInitStruct.GPIO_Mode = GPIO_Mode_OUT;
  gpioInitStruct.GPIO_OType = GPIO_OType_PP;
  gpioInitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  gpioInitStruct.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(GPIOB, &gpioInitStruct);

  // turn on clock for DAC
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
  // initialize DAC
  DAC_InitTypeDef dacInitStruct;
  dacInitStruct.DAC_Trigger = DAC_Trigger_None;
  dacInitStruct.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
  dacInitStruct.DAC_WaveGeneration = DAC_WaveGeneration_None;
  // initialize both DAC channels with structure settings above
  DAC_Init(DAC_Channel_1, &dacInitStruct);
  DAC_Init(DAC_Channel_2, &dacInitStruct);
  // enable both DAC channels
  DAC_Cmd(DAC_Channel_1, ENABLE);
  DAC_Cmd(DAC_Channel_2, ENABLE);

  // turn on clock for ADC1
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
  /* turn on highspeed internal clock
  RCC_HSICmd(ENABLE);
  while(!RCC_GetFlagStatus(RCC_FLAG_HSIRDY)); // wait until done
  // initialize common (ADC analog clock prescaler) - wtf is this?
  ADC_CommonInitTypeDef adcCommonInitStruct;
  adcCommonInitStruct.ADC_Prescaler = ADC_Prescaler_Div1;
  ADC_CommonInit(&adcCommonInitStruct);*/
  // initialize ADC
  ADC_InitTypeDef adcInitStruct;
  adcInitStruct.ADC_ScanConvMode = DISABLE;
  adcInitStruct.ADC_ContinuousConvMode = DISABLE;
  adcInitStruct.ADC_ExternalTrigConv = ADC_ExternalTrigConvEdge_None;
  adcInitStruct.ADC_DataAlign = ADC_DataAlign_Right;
  adcInitStruct.ADC_NbrOfConversion = 1;
  ADC_Init(ADC1, &adcInitStruct);
  // enable ADC1
  ADC_Cmd(ADC1, ENABLE);
  while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_ADONS));

  // turn on clock for timer4
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
  // initialize timer
  TIM_TimeBaseInitTypeDef timInitStruct;
  timInitStruct.TIM_Prescaler = 1;
  timInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  timInitStruct.TIM_Period = 200;
  timInitStruct.TIM_ClockDivision = 0;
  TIM_TimeBaseInit(TIM4, &timInitStruct);
  // initialize interrupts
  NVIC_InitTypeDef intInitStruct;
  intInitStruct.NVIC_IRQChannel = TIM4_IRQn;
  intInitStruct.NVIC_IRQChannelCmd = ENABLE;
  intInitStruct.NVIC_IRQChannelPreemptionPriority = 0x0F;
  intInitStruct.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_Init(&intInitStruct);
  // enable timer interrupt
  TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
  TIM_Cmd(TIM4, ENABLE);

  // turn on clock for timer3
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  // initialize timer
  timInitStruct.TIM_Prescaler = 1;
  timInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  timInitStruct.TIM_Period = 511;
  timInitStruct.TIM_ClockDivision = 0;
  TIM_TimeBaseInit(TIM3, &timInitStruct);
  // initialize pwm
  TIM_OCInitTypeDef ocInitStruct;
  ocInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
  ocInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  ocInitStruct.TIM_OutputState = TIM_OutputState_Enable;
  ocInitStruct.TIM_Pulse = 0;
  TIM_OC3Init(TIM3, &ocInitStruct);
  TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);
  TIM_Cmd(TIM3, ENABLE);
  // configure pwm pin
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
  gpioInitStruct.GPIO_Pin = GPIO_Pin_8;
  gpioInitStruct.GPIO_Mode = GPIO_Mode_AF;
  gpioInitStruct.GPIO_OType = GPIO_OType_PP;
  gpioInitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  gpioInitStruct.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(GPIOC, &gpioInitStruct);
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_TIM3);

  /* turn on clock for timer9
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM9, ENABLE);
  // initialize timer
  timInitStruct.TIM_Prescaler = 1;
  timInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
  timInitStruct.TIM_Period = 511;
  timInitStruct.TIM_ClockDivision = 0;
  TIM_TimeBaseInit(TIM9, &timInitStruct);
  // initialize pwm
  TIM_OCInitTypeDef ocInitStruct;
  ocInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
  ocInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
  ocInitStruct.TIM_OutputState = TIM_OutputState_Enable;
  ocInitStruct.TIM_Pulse = 0;
  TIM_OC1Init(TIM9, &ocInitStruct);
  TIM_OC1PreloadConfig(TIM9, TIM_OCPreload_Enable);
  TIM_Cmd(TIM9, ENABLE);
  // configure pwm pin
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
  gpioInitStruct.GPIO_Pin = GPIO_Pin_13;
  gpioInitStruct.GPIO_Mode = GPIO_Mode_AF;
  gpioInitStruct.GPIO_OType = GPIO_OType_PP;
  gpioInitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  gpioInitStruct.GPIO_Speed = GPIO_Speed_40MHz;
  GPIO_Init(GPIOB, &gpioInitStruct);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_TIM9);*/
}

In halfSin[] sind 100 in Excel erstellte Werte einer Sinushalbwelle (ich 
weiß, eine Viertelwelle reicht, aber so ist es übersichtlicher), um 
jedoch später noch genug Zeit für das Einlesen und Verarbeiten der 
anderen Pegel zu haben, lese ich nur jeden 2ten Wert aus, auf dem Oszi 
sieht man die Stufen kaum.

Um das PWM Signal zu filtern, nehme ich einen einfachen Spannungsteiler: 
"oben" 1kOhm, "unten" 100nF, Messkopf an Mitte.


Kennt ihr bessere, elegantere Möglichkeiten, ein 400Hz Sinus zu 
erzeugen, oder linear in der Amplitude zu modulieren (den 
gleichgerichtetet Sinus könnte man ja auch über Spannungsteiler mit 
einem Transistor runterziehen, welcher mit einem DC Signal gespeist 
wird, nur die Kurvenform leidet doch darunter, oder?)? Oder wisst ihr, 
wie man den ollen Puffer des DAC fixt?

[Jim M. (turboj)]

Du hast ein paar Mal 4059 statt 4095 in obigem Code.

Delay() ignoriert je nach Implementation eventuell die Zeit, die in 
Interrupts zwischendurch verbraten wurde.

Dein Timer 4 läuft relativ schell - 200 Takte hat man schnell mal auch 
im Interrupt verbraten. Sind beim Compiler die Optimierungen an?

Quellcode bitte das nächste Mal als .c Datei anhängen, wenns nicht nur 
eine Handvoll Zeilen ist.

[Niklas B. (niklas90)]

Danke für die Hinweise.


Klar, es muss natürlich immer 4095 sein, da hatte ich mich wohl vertippt 
:).

Das Delay() kommt später noch weg, das war nur da damit man das Leuchten 
der grünen LED besser wahrnimmt wenn man das Touchpad berührt, das ist 
alles nur zum Testen ob man gleichzeitig das 400Hz Signal im 
Timerinterrupt erzeugen kann und Pegel einlesen und verarbeiten kann. 
Das wird später natürlich noch viel komplexer.

Das bringt mich zu dem Punkt mit dem Timer 4: Der µC hat 200 Takte Zeit 
andere Berechnungen vorzunehmen und Pegel einzulesen wenn gerade nicht 
der Sinus erzeugt wird, ich denke dass ist nicht gerade viel, im 
Gegenteil, ich hatte Angst dass man nicht hinterherkommt und deshalb 
sogar die Period von 100 auf 200 gesetzt und nur jeden 2ten Wert des 
Arrays ausgegeben.

Mich beschleicht nur das Gefühl, dass der µC gar nicht mit 16MHz rennt, 
sondern nur mit 8: Nehmen wir an, er liefe mit 8MHz, und ich würde jeden 
Wert aus dem Array auslesen, also 200 Werte für eine gleichgerichtete 
Sinusperiode, also 2 Halbwellen a 100 Werte und ich würde die Period des 
Timer 4 auf 100 stellen, dann komme ich auf 8000000Hz/100/200 = 400Hz, 
also genau die gewünschte Frequenz.

Warum läuft der µC mit 8MHz, obwohl ich die HSI angeschaltet habe? 
Eigentlich sollte die doch mit 32MHz laufen, RCC_GetClocksFreq(&clock); 
spuckt mir 16MHz aus, was mache ich falsch dass er mit 8MHz läuft?


Mit dem C-Code hast du recht, nur manche haben wahrscheinlich keine Lust 
erst die Datei zu laden und in ihrem Editor zu öffnen, eine Art 
Spoiler-Funktion im Forum zum auf-und zuklappen wäre nett.

[Jim M. (turboj)]

Es gibt eine Preview Funktion für C Code hier im Forum. Einfach die 
Datei mit Endung.c hochladen...

[Niklas B. (niklas90)]

Ich habe jetzt den Fehler für die Kurvenform gefunden. Ich gebe ja das 
Signal an PA4 aus, auf dem Discovery Board ist dieser Pin mit einem 1µF 
verbunden, ich hab die Brücke zu ihm rausgelötet, jetzt sieht das Signal 
wunderbar aus.