Hochauflösender Systemtimer in STM32

Wie Sie festgestellt haben, ist die Handhabung des Zählerüberlaufs mit einem Interrupt-Handler schwierig und rennanfällig. Selbst mit Ihrer Prioritätserhöhung erhalten Sie die falsche Antwort, wenn Interrupts deaktiviert sind, während Sie den Zähler ablesen. Es gibt eine viel einfachere Technik, die funktioniert, wenn Sie die Uhr nicht aus dem Interrupt-Kontext lesen (beachten Sie, dass ich hier den DWT-Zykluszähler verwende, der so schnell und einfach in den Prozessor integriert ist):

uint64_t last_cycle_count_64 = 0;

// Call at least every 2^32 cycles (every 59.6 seconds @ 72 MHz).
// Do not call from interrupt context!
uint64_t GetCycleCount64() {
  last_cycle_count_64 += DWT->CYCCNT - (uint32_t)(last_cycle_count_64);
  return last_cycle_count_64;
}

Wenn Sie es aus dem Interrupt-Kontext aufrufen müssen (oder mit einem präemptiven Betriebssystem):

volatile uint64_t last_cycle_count_64 = 0;

// Call at least every 2^32 cycles (every 59.6 seconds @ 72 MHz).
uint64_t GetCycleCount64() {
  uint32_t primask;
  asm volatile ("mrs %0, PRIMASK" : "=r"(primask));
  asm volatile ("cpsid i");  // Disable interrupts.
  int64_t r = last_cycle_count_64;
  r += DWT->CYCCNT - (uint32_t)(r);
  last_cycle_count_64 = r;
  asm volatile ("msr PRIMASK, %0" : : "r"(primask));  // Restore interrupts.
  return r;
}

Möglicherweise müssen Sie zuerst den Zykluszähler aktivieren:

DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;  // Set bit 0.

Ihr Code hat zwei Probleme:

• Sie wissen nicht, ob der Interrupt, der sich erhöht hat, SysTickMajorvor oder nach dem Einlesen des Timer-Werts in aufgetreten ist time.

• Operationen auf 64-Bit-Werten sind auf einem 32-Bit-System nicht atomar. Der Wert für SysTickMajorkönnte also durch den Interrupt zwischen dem Lesen der beiden 32-Bit-Wörter aktualisiert werden.

Ich würde es wie folgt machen:

major0 = SysTickMajor;
minor1 = SysTick->VAL;
major1 = SysTickMajor;

minor2 = SysTick->VAL;
major2 = SysTickMajor;

if ( major0 == major1 )
{
    time = major1 + minor1;
}
else
{
    time = major2 + minor2;
}

Hier gehen Sie davon aus, dass sich SysTickMajoreine Änderung im ersten Aufgabenblock im zweiten Block nicht mehr ändert. (Diese Annahme könnte falsch sein, wenn dieser Code während dieser Routine unterbrochen wird und längere Zeit nicht ausgeführt werden kann.)

Siehe auch diese Frage zu Stackoverflow .

Ich habe gerade die Antwort von einem sehr hilfreichen Poster im STM32-Forum gefunden:

Folgendes ist nicht korrekt. SysTick ist ein 'System Handler', und als solcher wird die Priorität überhaupt nicht auf diese Weise festgelegt:

  NVIC_InitStructure.NVIC_IRQChannel = SysTick_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // Highest priority
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

Es ist eigentlich eingestellt mit:

  NVIC_SetPriority(SysTick_IRQn, 0);

Das Aufrufen dieses Codes löst das Problem stattdessen!

Meine Version von getSystemTime könnte also ein Problem gehabt haben, und die Methode von starblue ist besser als meine - die eigentliche Ursache der Probleme war jedoch die oben genannte.

Ich dachte nur, ich würde getSystemTime eine weitere mögliche Verbesserung hinzufügen, die ich auch ausprobiert habe:

do {
 major0 = SysTickMajor;
 minor = SysTick->VAL;
 major1 = SysTickMajor;
while (major0 != major1);
return major0 - minor;

Dadurch wird das Problem, bei dem Sie (irgendwie) dazu führen könnten, dass der SysTick zweimal in sehr schneller Folge implementiert wird, effektiv negiert.

Die vorherigen Antworten sind großartig. Dieses hier gefällt mir am besten:

do {
 major0 = SysTickMajor;
 minor = SysTick->VAL;
 major1 = SysTickMajor;
while (major0 != major1);
return major0 - minor;

Sie können es noch ein bisschen optimieren, da Sie wissen, dass Sie bei einem Rollover von SysTickMajor „lange Zeit“ keinen weiteren Rollover mehr bekommen werden. Sie sollten sicher sein, dies zu tun:

major = SysTickMajor;
minor = SysTick->VAL;
if (major != SysTickMajor)
    return SysTickMajor - SysTick->Val;
return major - minor;

Das Obige setzt natürlich voraus, dass SysTickMajor und VAL als flüchtig deklariert sind. Vor einigen Jahren habe ich bei einem früheren Job festgestellt, dass das Obige leider immer noch nicht auf allen Prozessoren perfekt ist. Ich habe einen STM32F407 verwendet, der über einen Cache verfügt und über eine Pipeline verfügt. Manchmal kam der Abruf des zweiten SysTickMajor vor dem VAL an, obwohl sie in der richtigen Reihenfolge ausgegeben wurden. Geben Sie die Speicherbarriere ein (dmb-Anweisung):

major = SysTickMajor;
minor = SysTick->VAL;
__asm__ volatile("dmb");
if (major != SysTickMajor)
    return SysTickMajor - SysTick->Val;
return major - minor;

In meinem Fall habe ich ein 32-Bit-TIM2 und ein TIM2-Rollover-ISR verwendet, das die oberen 32 Bits meines 64-Bit-Zykluszählers erhöht, aber ich denke, es sollte sich genauso verhalten wie das, was Sie mit SysTick tun.