Как иметь дело с переносящимся счетчиком во встроенном C

Если вы используете беззнаковые переменные для хранения вашего счетчика и времени истечения таймера, вы можете просто используйте этот тест:

if (current_time - expiry_time < 0x80000000UL)
    /* timer has expired */

Предполагается, что вы проверяете истечение срока по крайней мере один раз каждые 0x80000000 тиков, и что ваш самый длинный таймер установлен на истечение менее 0x80000000 тиков в будущем.

Одна из возможностей состоит в том, чтобы преобразовать обе переменные в 64-битную длину и затем произвести суммирование. После этого сравните с максимальным 32-битным значением, чтобы определить, упакован ли он.

Приведите результат вычитания без знака к подписал и сравнил с нулем. Должен справиться с переполнением, когда вы проверяете его достаточно часто (а ваш тайм-аут составляет менее половины диапазона вашего таймера).

uint32_t timer( void);             // Returns the current time value
uint32_t timeout;

timeout = timer() + offset;

// wait until timer() reaches or exceeds timeout value
while ((int32_t)(timeout - timer()) > 0);

предположим, что счетчик отсчитывает время (многие отсчитывают время, чтобы сэкономить на гейтах в логике).

сначала вам нужно узнать период времени, который потребуется, чтобы дойти до 2^32 тиков, и убедиться, что вы хорошо передискретизируете это время.

Если вы хотите найти промежуток времени между двумя событиями, скажем, start и end

start = read timer последнее время = начало rollover = 0

в ожидании того, что произойдет

nowtime = read timer if(nowtime>lasttime) rollover+=1 (это понижающий счетчик) lasttime = nowtime

событие произошло: end = считать таймер

total time = start - end (это счетчик вниз, и заметьте, что эта математика работает даже при перевороте)

total time = общее время / масштабный коэффициент для перехода от тиков к секундам, минутам, чему угодно общее время += rollover * секунды/минуты/что угодно на 2^32 отсчетов

если у вас есть счетчик вверх, то nowtime

Если вы можете гарантировать, что ваше событие произойдет в течение 2^32 отсчетов, вам не нужно делать ролловер nowtime last time, вам нужно только начало и конец, и общее количество тиков = начало - конец будет работать, даже если счетчик скачет от 0x00000000 до 0xFFFFFFFF между началом и концом.

Поскольку вы встраивались, у вас может быть доступ к биту переполнения ЦП. Это будет установлено, когда добавление переполняет регистр. Полезно для добавления цепочки AddCarry.

Я думаю, что один из самых простых способов сделать это - иметь другой счетчик (назовем его Wrap counter, пусть он будет статическим глобальным для модуля таймера), подсчитывающий каждый раз, когда ваш исходный 32-битный счетчик оборачивается.

В функции, где ваш счетчик тикает, каждый раз, когда этот счетчик достигает своего максимального значения, у вас есть приращение счетчика Wrap. Поэтому, когда вы читаете функцию, которая возвращает, истек ли таймер, вы также читаете счетчик Wrap, чтобы проверить, сколько раз он был перенесен. Важно также сделать это: каждый раз, когда вы читаете счетчик переноса, вы хотите очистить его для следующего чтения.

Это не будет иметь значения до тех пор, пока разница между начальным и конечным отсчетом меньше (2^32)/2, и при условии, что выполняется 32-битная арифметика с дополнением 2 (почти универсально верно), даже если значение отсчета охватывает точку обертывания. Например:

Start count: 0xfffffff
End Count:   0x00000002 (incremented through 0,1,2 - i.e. three counts)

End - Start == 0x00000002 - 0xfffffff == 0x00000003

Таким образом, правильный ответ достигается до тех пор, пока ширина счетчика равна ширине бита встроенного целочисленного типа, и этот тип используется. Если, возможно, ширина регистра счетчика не соответствует встроенному целочисленному типу, можно добиться того же эффекта, маскируя биты "переполнения" старшего порядка.

Если вам нужен больший счет по другим причинам или если разница между последовательными метками времени слишком велика, то вы можете просто использовать другое целое число, которое увеличивается, когда счетчик младшего порядка сворачивается. Это целое число будет формировать старшие биты большего целого числа, так что LSB второго целого числа будет 33-м битом этого большего целого числа.

Вопрос немного расплывчатый. Одна из возможностей — установить флаг, когда вы впервые заметите, что время истекло. Верным способом было бы добавление второго счетчика, который увеличивается при переполнении первого счетчика. Это фактически создаст 64-битный счетчик, который не будет переполняться.

Самый простой способ сделать это — сделать «счетчик эпох», который явно подсчитывает ролловер. (Пример: у вас есть аппаратный счетчик, который отсчитывает секунды 0..59. Ваш счетчик эпох будет считать минуты, приращая каждый раз, когда он замечает, что счетчик секунд перевернулся.)

Функция future_scheduler затем считывает текущую эпоху и время и вычисляет новую эпоху и время для вашего события.

Кроме того, вы можете просто ударить и заставить свою функцию синхронизации подсчитывать ваши расписания событий до нуля на каждом тике таймера.

Предполагая, что вы имеете дело с беззнаковыми типами, вы можете довольно легко проверить обертку -

if (timestamp + shifftime < timestamp) 
    it_wrapped();