Tastverhältnis 0/4,1/4,3/4 auf STM32 programmieren

[J. -. (Gast)]

Grüß euch,

gerade habe ich auf dem AVR mein erstes C-Programm geschrieben, das in 
der main-Schleife nichts als luftleeren Raum enthält ;)
Es geht um Funksteckdosen, und mit OCRA und OCRB kann man das auf dem 
AVR recht effizient erledigen.
Was ich brauchte, war ein Signal mit ~3900Hz, und eben obige Bitzeiten; 
was auch gut klappt.
Falls jemand das brauchen kann oder sogar sucht (obwohl der Hype um die 
Protokolle ja längst gegessen ist und genügend Dokumentation der Sache 
da ist), hier ein Snip:

//ATMega32, F_CPU 14,7456 MHz
#define FAM 4600
volatile uint8_t cnt=0,bit=0;
volatile uint8_t code[32]={1,3,1,1,1,3,1,3,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,3,1,0,0,0,0,0,0,0}; //Code A, code[23] = on/off
//volatile uint8_t code[32]={1,3,1,1,1,3,1,3,1,3,1,1,1,1,1,1,1,1,1,3,1,3,1,3,1,0,0,0,0,0,0,0}; //Code B, code[23] = on/off
//volatile uint8_t code[32]={1,3,1,1,1,3,1,3,1,1,1,3,1,1,1,1,1,1,1,3,1,3,1,3,1,0,0,0,0,0,0,0}; //Code C, code[23] = on/off
//volatile uint8_t code[32]={1,3,1,1,1,3,1,3,1,3,1,3,1,1,1,1,1,1,1,3,1,3,1,3,1,0,0,0,0,0,0,0}; //Code D, code[23] = on/off

int main (void) 
{
//AM433
DDRD |= (1<<PD0);
PORTD &= ~(1<<PD0); //Ausgangsport -> zum Eingang Amplitudenmodulation 433MHz-Sender

//Setze Timer 1 auf ca. 300µs CTC
TCCR1A = 0;
TCCR1B = (1<<WGM12)|(1<<CS10); //
OCR1A = 4*FAM;//3; //50 Hz ^ 20ms
OCR1B = FAM;//3; //50 Hz ^ 20ms
TIMSK = (1<<OCIE1A)|(1<<OCIE1B);
TCNT1 = 0;
while(1)
{
    switch (cnt)
    {//test ein- und ausschalten Kanal B/C
      case 64:
        code[23] = 1;
        code[9] = 3;
        code[11] = 1;
      break;
      
      case 128:
        code[23] = 1;
        code[9] = 1;
        code[11] = 3;
      break;

      case 192:
        code[23] = 3;
        code[9] = 3;
        code[11] = 1;
      break;

      case 0:
        code[23] = 3;
        code[9] = 1;
        code[11] = 3;
      break;
    }

}
}
//-------------------------------------------------------------------------
ISR (TIMER1_COMPA_vect)
{
  OCR1B = code[bit]*FAM;
  if (code[bit]>0) PORTD |= (1<<PD0);
  if (bit++>31)
  {
    bit=0;
    OCR1B = code[bit]*FAM;
    cnt++;
  }
}
//-------------------------------------------------------------------------
ISR (TIMER1_COMPB_vect)
{
  PORTD &= ~(1<<PD0);
}

Das ist natürlich noch nicht optimal, sondern code[] gehört noch in eine 
32-bit-variable, aber es tut und ich will es auf dem AVR auch nicht 
nutzen.


Bei dem STM32 würde ich es so machen, daß ich einen Timer auf die 
entsprechende Periodendauer einstelle (1 / 3900Hz), und zuvor wie oben 
vorerst mal 32 Variablen setze mit Werten von 0,1 oder 3. So würde man 
das auf jeden Fall geknackt kriegen. Aber ich weiß nicht, ob es schlau 
ist.

Schlauer wäre es, wenn es beim STM32-Timer auch diese Art OC-Interrupts 
wie beim AVR gäbe. Noch schlauer wär's wahrscheinlich, wenn man das 
entsprechende Manual liest g

Wie würdet ihr das machen? Einfach einen Timer aufsetzten, und die 
Bitzeiten per Software abnudeln wie o.a., oder eher mit (evtl. 
vorhandenen) Timerfunktionen?

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

Jürgen S. schrieb:
> Schlauer wäre es, wenn es beim STM32-Timer auch diese Art OC-Interrupts
> wie beim AVR gäbe. Noch schlauer wär's wahrscheinlich, wenn man das
> entsprechende Manual liest g

Zumindest der 'Advanced Timer' (einen davon sollte dein STM32 mindestens 
haben) bietet 3 (oder warens 4?) CC Register mit je einem Interrupt und 
den entsprechenden PWM Ausgängen.

Jürgen S. schrieb:
> Wie würdet ihr das machen? Einfach einen Timer aufsetzten, und die
> Bitzeiten per Software abnudeln wie o.a., oder eher mit (evtl.
> vorhandenen) Timerfunktionen?

Faul, wie ich bin, lasse ich das den Interrupt machen, damit ich in der 
Hauptschleife anderen Krams machen kann. Allerdings nehme ich im 
Motorkontroll Projekt dafür den Overflow Interrupt und nicht die CC's.

[Jan B. (berge)]

Moin,
ich habe nicht genau verstanden, was du machen willst und verstehe den 
AVR Code auch nicht auf Anhieb. Wenn ich richtig interpoliere, brauchst 
du 1x eine zyklische Abtastung eines Eingangs und 1x ein zyklisches 
Setzen eines Ausgangs.

Wenn ein OC IRQ ein "Overcount" ist, dann ja, so etwas gibt es auf den 
STM32s. Hier http://mikrocontroller.bplaced.net/wordpress/?page_id=2251 
gibt es eine Library für Timer, die genau diesen IRQ Typ nutzt. Du 
kannst in der Callback Funktion dann den Code platzieren, den du 
ausgeführt haben magst. Für die Berechnung des Prescalers und der 
Periode habe ich den Libraries eine Funktion hinzugefuegt:

void UB_TIMER2_Init_WithFrequency( float desiredFreqInHz )
{
    // Hole Eingangstakt des Timers
    RCC_ClocksTypeDef RCC_Clocks;
    RCC_GetClocksFreq(&RCC_Clocks);
    int inputClkFreq = RCC_Clocks.PCLK1_Frequency;

    // Berechne prescaler und periode
    int frequencyDivNecessary = (float) inputClkFreq / desiredFreqInHz;
    frequencyDivNecessary >> 16;  // Schiebe 16 Bit nach links, da 16 Bit breite periode moeglich
    int timerMaxCountValue = ( inputClkFreq / (frequencyDivNecessary + 1) ) / desiredFreqInHz;

  // Setze Timer auf
  UB_TIMER2_Init(frequencyDivNecessary, timerMaxCountValue);
}

Hoffe das hilft dir.
Liebe Grüße, Jan

[J. -. (Gast)]

Matthias Sch. schrieb:

> Faul, wie ich bin, lasse ich das den Interrupt machen, damit ich in der
> Hauptschleife anderen Krams machen kann. Allerdings nehme ich im
> Motorkontroll Projekt dafür den Overflow Interrupt und nicht die CC's.
Ja klar, das ist das Beste so ;)
Ich habe mich inzwischen ein bißchen durch das Manual durchgelesen und 
brauche die Komplexität von Timer 1 oder 8 nicht. Jetzt habe ich den 
TIM4 als normale PWM aufgesetzt, und es geht.
Am meisten Kopfzerbrechen hat mir der Zugriff auf Register 0x40000834 
(CCR1 von TIM4) bereitet (wie, wieso, was ist mit dem Offset etc.), bis 
ich dann in den Systembibliotheken nach TIM_pulse gesucht habe und dann 
TIM4->CCR1 = x fand; damit ist alles erledigt.
Anfangs neigt man ja dazu, immer die gesamte InitStruktur nochmal 
durchzunudeln, weil man es nicht besser weiß. Das war jetzt also die 
erste, erfolgreiche Registerprogrammierung g


Jan Berg schrieb:
> Moin,
> ich habe nicht genau verstanden, was du machen willst und verstehe den
> AVR Code auch nicht auf Anhieb. Wenn ich richtig interpoliere, brauchst
> du 1x eine zyklische Abtastung eines Eingangs und 1x ein zyklisches
> Setzen eines Ausgangs.
Hallo Jan, danke für Deinen Code. Es ist viel trivialer als es 
angekommen ist, es braucht keinen Inputpin.
Der AVR-Code oben macht einfach eine konstante Zeitdauer mit OCA 
(sozusagen ein verkürzter Overflow-Interrupt mit Periode 4*FAM), und 
unterteilt diese Zeitdauer mittels OCB nochmal, also macht nichts anders 
als ein Tastverhältnis; und das 32mal hintereinander.
Die Library von Uwe Becker habe ich schon oft einsetzen können, ist 
wirklich ein tolles, hilfreiches Stück Arbeit, was da dahintersteckt.
Prinzipiell schalte ich jetzt so ähnlich wie von Dir vorgeschlagen im 
Interrupt des Timers die "Bits" um und weiter. Es gefällt mir allerdings 
noch nicht so richtig (es funktioniert sehr gut und blockiert auch 
nicht, aber wenn ich die Macht der Timer abschätze, steckt in meinem 
Progrämmchen noch eine Menge Verbesserungspotential ;) )

Danke euch beiden und Gruß