Timer Finder Opta (STM32H747XI)

[Holger (holger_p2)]

Hallo,
ich versuche auf einer Finder Opta einen Timer zu 
programmieren.Prozessor der Steuerung ist ein STM32H747XI.

Umgebung ist Arduino.

Ich bin ziemlicher Anfaenger und fuer jede Hilfe dankbar.


1. Problem. Wieso brauch ich einen Delay bevor ich was in das ARR bzw. 
PSC Register schreibe.

2. Problem. Wenn ich den Interrupt fuer den Timer aktiviere (Zeile39) 
geht das Programm in die Wueste.Ich bin nicht sicher ob der Name fuer 
den Interrupt Handler korrekt ist. Ich bin auch nicht sicher ob ich den 
irgendwie als ISR Kennzeichnen muss. Wie ich das verstehe wird der im 
Startup in der Interrupt Vektor Tabelle definiert. Wie ist die Verbinung 
von meinem Handler zur Tabelle?

Ohne Interrupt laeuft das Programm. Die While schleife wird durchlaufen, 
Micros sind etwa 1 Million. Im Anschluss geht die LED aus.

#include "stm32h747xx.h"
#include "timer.h"

void TIM14_IRQHandler(void) {
  if (TIM14->SR & TIM_SR_UIF) {
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
    TIM14->SR &= ~(TIM_SR_UIF);
  }
}

//---------------------------------------------------------
void setup()
{
// configure pin in output mode
  pinMode(LED_BUILTIN,  OUTPUT);
  pinMode(LED_USER, OUTPUT);
  digitalWrite(LED_USER, HIGH);  // laeuft
  
  Serial.begin(115200);
  while (!Serial); // warte bis terminal offen
  delay(100);
  Serial.print(F("\nStart "));

  digitalWrite(LED_BUILTIN, LOW);  
//---------------------------------------------------------
  RCC->APB1LENR |= RCC_APB1LENR_TIM14EN;        // enable timer14 clock
  TIM14->CR1 &= ~(TIM_CR1_CEN);                 // Timercount disable
  RCC->APB1LRSTR |= (RCC_APB1LRSTR_TIM14RST);   // reset timerblock14
  RCC->APB1LRSTR &= ~(RCC_APB1LRSTR_TIM14RST);
delay(10);
  TIM14->ARR = 10000;                            // 10000 * 0.1 ms = 1sec
  TIM14->PSC = 19999;                           // prescale -> frequenz =16000000 / 16000 = 1KHz  so ist es 0.1ms??
  Serial.println("--0");
  TIM14->EGR |= TIM_EGR_UG;                     // update psc und arr
  TIM14->DIER |= TIM_DIER_UIE;                  // enable timer irq
  Serial.println("--1");
  TIM14->SR &= ~TIM_SR_UIF;                     // clear interrupt flag
  Serial.println("--2");
//  NVIC_EnableIRQ(TIM14_IRQn);                   // Enable the NVIC interrupt for TIM14
  Serial.println("--3");
  TIM14->CR1 |= TIM_CR1_CEN;                    // enable timer

Serial.println(TIM14->PSC);
Serial.println(TIM14->ARR);

  uint32_t t1=0,t2=0;

  while(t2 < 20){
    while ((TIM14->SR & TIM_SR_UIF) == 0);
    TIM14->SR &= ~TIM_SR_UIF;
    Serial.println(micros() - t1);
    t1=micros();
    t2++;
  }
  digitalWrite(LED_USER, LOW);
}

void loop()
{

}

[Niklas G. (erlkoenig)]

Holger schrieb:
> Wieso brauch ich einen Delay bevor ich was in das ARR bzw. PSC Register
> schreibe.

Nachdem du den Timer im RCC aktiviert hast, dauert es ein paar Takte bis 
sich das auswirkt, weil die CPU schneller als der Bus ist. Füge 
dazwischen ein

__DSB();
__ISB();

ein, damit die CPU die Vervollständigung des Schreibzugriffs abwartet.

Holger schrieb:
> ch bin nicht sicher ob der Name fuer den Interrupt Handler korrekt ist

Der korrekte Name lautet "TIM8_TRG_COM_TIM14_IRQHandler". Ist im Startup 
Code definiert:

https://github.com/STMicroelectronics/cmsis_device_h7/blob/13ba9da797a30e1563a8795f974425fb26dd0457/Source/Templates/gcc/startup_stm32h747xx.s#L191

Der Name kommt daher, dass sich manchmal mehrere Peripherals den selben 
Interrupt teilen. Im Handler musst du dann prüfen, ob der gewünschte 
Interrupt aufgetreten ist.

Schreibe den Interrupt besser so:

void TIM14_IRQHandler(void) {
  if (TIM14->SR & TIM_SR_UIF) {
    TIM14->SR = ~(TIM_SR_UIF);

    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }
}

Man sollte das UIF Flag so schnell wie möglich löschen, weil auch dieser 
Zugriff etwas dauert; macht man das am Ende der ISR, kann die ISR 
eventuell direkt noch einmal auslösen. Außerdem ist kein 
Read-Modify-Write ( "&=" ) nötig, es reicht einfach der direkte 
Schreibzugriff, weil die Bits im Register als "rc_w0" definiert sind (1 
schreiben = keine Wirkung, 0 schreiben = löschen).

[Holger (holger_p2)]

Hallo,
danke fuer die schnelle Antwort.

Das mit dem Delay habe ich mir so halb gedacht.

Den Handler habe ich jetzt geaendert zu

void TIM8_TRG_COM_TIM14_IRQHandler(void) {
  if (TIM14->SR & TIM_SR_UIF) {
    TIM14->SR = ~(TIM_SR_UIF);
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }
}

aber das Programm haengt immer noch. Startup werde ich mir jetzt 
anschauen.

Ich verstehe den Zusammenhang von der Vektortabelle und meinem Handler 
nicht.
Zu DOS Zeiten war in der Vektortabelle direkt die Einsprungadresse des 
Handlers

[J. S. (jojos)]

Im Startup Code sind dummy Handler in der Vektortabelle. Diese dummy 
Handler sind als 'weak' definiert, d.h. sie werden überschrieben (vom 
Linker ersetzt) wenn sie im Code vorhanden sind.

[Holger (holger_p2)]

Ok. Das habe ich verstanden.

Dann muss ich bei mir auf dem Rechner irgendwo ein FILExxx.s heben, dass 
der Linker verwendet. Ich hab bis jetzt nur eins gefunden mit 0-15 was 
ja jeder ARM gleich hat.

Oder muss ich das oben verlinkte File irgendwohin kopieren?

[J. S. (jojos)]

Der startup code steckt kompiliert in einer library drin, den kannst du 
nicht einfach ersetzen oder verändern. Es wird auch nicht der aus dem 
CMSIS Beispiel verwendet, sondern der steckt im ArduinoCore-mbed drin.

Wichtig ist aber den Handler als 'extern "C"' zu definieren, jetzt wird 
der als C++ Unit übersetzt und durch das Name mangeling passt der 
tatsächliche Funktionsname nicht zu der Definition im Startup Code.

[Holger (holger_p2)]

Herzlichen Dank

und so

extern "C"{
  void TIM8_TRG_COM_TIM14_IRQHandler(void) {

    if (TIM14->SR & TIM_SR_UIF) {
      TIM14->SR = ~(TIM_SR_UIF);
      digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
    }
  }
}

funktioniert das jetzt einwandfrei.

Kann ich mir morgen mal das extern "C" zu Gemuete ziehen

Danke
Holger

[J. S. (jojos)]

C++ name mangeling ist das Stichwort.
In C++ sind ja mehre Signaturen für Funktionen mit gleichen Namen 
erlaubt, z.B.

void foo(int a);
void foo(float a);

Dadurch würde der Linker bei C meckern, in C++ werden die Argumente in 
den Funktionsnamen reinkodiert und damit sind die wieder eindeutig.
Mit 'extern "C"' verhindert man dieses name mangeling um es C kompatibel 
zu machen.

Aber auch obwohl ich das weiß habe ich an dem blöden fehlenden extern 
"C" auch schon lange den Fehler gesucht :)
Und deshalb ich das 'weak' nicht besonders, der Linker kann solche 
Fehler nicht erkennen weil er ja nicht weiß ob die Funktion ersetzt 
werden soll oder nicht. Aber es ist eben ein Mittel um eine generisches 
Modul zu haben wo die Funktion beim Linken ersetzt werden kann.

[Holger (holger_p2)]

Ja, ich habe mir den Artikel auf Wikipedia quer gelesen. Hat halt alles 
Vor- und Nachteile.