Системный таймер высокого разрешения в STM32

Как вы уже поняли, обработка переполнения счетчика с помощью обработчика прерываний сложна и подвержена гонкам. Даже с повышением приоритета вы получите неправильный ответ, если прерывания отключены, пока вы читаете показания счетчика. Существует гораздо более простой метод, который работает, если вы не читаете часы из контекста прерывания (обратите внимание, что здесь я использую счетчик циклов DWT , который встроен в процессор так быстро и просто):

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;
}

Если вам нужно вызвать его из контекста прерывания (или с вытесняющей ОС):

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;
}

Возможно, вам потребуется сначала включить счетчик циклов:

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

В вашем коде две проблемы:

• Вы не знаете, произошло ли прерывание, которое увеличилось, SysTickMajorдо или после того, как вы прочитали значение таймера в time.

• Операции с 64-битными значениями не являются атомарными в 32-битной системе. Таким образом, значение for SysTickMajorможет быть обновлено прерыванием между чтением двух 32-битных слов.

Я бы сделал это следующим образом:

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

minor2 = SysTick->VAL;
major2 = SysTickMajor;

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

Здесь вы предполагаете, что если SysTickMajorизмениться в первом блоке присваиваний, то во втором блоке он не изменится снова. (Это предположение может быть неверным, если этот код прерывается во время этой процедуры и не может выполняться в течение длительного времени.)

См. также этот вопрос на Stackoverflow .

Я только что нашел ответ на очень полезном плакате на форуме STM32:

Следующее неверно. SysTick — это «системный обработчик», и поэтому приоритет не устанавливается таким образом:

  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);

На самом деле он установлен с:

  NVIC_SetPriority(SysTick_IRQn, 0);

Вместо этого вызов этого кода решает проблему!

Таким образом, моя версия getSystemTime могла иметь проблемы, а метод starblue лучше, чем мой, однако фактическая причина проблем была указана выше.

Просто подумал, что добавлю еще одно возможное улучшение в getSystemTime, которое я тоже пробовал:

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

Это эффективно сведет на нет проблему, когда вы можете (каким-то образом) в конечном итоге реализовать SysTick дважды в очень быстрой последовательности.

Предыдущие ответы великолепны. Мне больше всего нравится вот это:

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

Вы можете еще немного оптимизировать его, поскольку знаете, что если у вас есть обновление SysTickMajor, вы не получите еще одно обновление «долгое время». Вы должны быть в безопасности, делая это:

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

Вышеизложенное предполагает, конечно, что SysTickMajor и VAL объявлены как volatile. Несколько лет назад, работая на предыдущей работе, я обнаружил, что, к сожалению, все вышеперечисленное работает не на всех процессорах. Я использовал STM32F407, у которого есть кеш и конвейер. Иногда выборка второго SysTickMajor прибывала до VAL, даже если они выдавались по порядку. Введите барьер памяти (инструкция dmb):

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

В моем случае я использовал 32-битный TIM2 и ISR с пролонгацией TIM2, который увеличивает старшие 32 бита моего 64-битного счетчика циклов, но я думаю, что он должен действовать так же, как вы делаете с SysTick.