Отрегулируйте расчет времени после изменения частоты Timer0

Вы установили MICROSECONDS_PER_TIMER0_OVERFLOW правильное значение, однако оно используется только MILLIS_INC, который, в свою очередь, используется только millis() . Это означает, что другие функции синхронизации, такие как micros(), delay(), delayMicroseconds(), прерываются при изменении timer0. Это своего рода ошибка, и она может быть исправлена в будущей версии, но на данный момент библиотеки Arduino ожидают, что вы оставите timer0 в покое. Лучший обходной путь — использовать millis() только для критических по времени функций.

ЭТО НЕПОЛНЫЙ ОТВЕТ. Эдгар знает, о чем говорит, послушайте его

Сейчас я работаю над тем же, но на ATMega2560. Этот веб-сайт помог мне лучше понять функцию millis() . Таймер переполняется каждые 510 отсчетов (см. техническое описание, стр. 123 для atmega2560). Я считаю, что это 510, а не 512, потому что он считает вверх и вниз, но не повторяет счет вверху или внизу - например, если вы считаете, начиная с 1 до 10, а затем обратно (без повторения 10), у вас будет подсчитано 19 раз, а не 20. Этот счетчик начинается с 0, считает до 255, а затем возвращается к 0, вызывая переполнение, прежде чем снова достигнет 0. Это 256 (счет вверх, включая 0 и 255) + 254 (счет вниз, не включая 255 или 0) = 510. Я написал скрипт на Python, чтобы визуализировать эффект этих изменений и попытаться их учесть. Это считается до 10 миллионов, поэтому для запуска требуется время, но к концу, даже с масштабированием, ошибка, если просто настроить millis() после факта, может составлять ~ 7 секунд.

#! /usr/bin/окружение Python
импортировать numpy как np

realT = np.zeros (10000000)
timer0_millis = np.zeros (10000000)
timer0_fract = np.zeros (10000000)
я=0

для i в диапазоне (1 10000000):
timer0_millis[i] = timer0_millis[i-1] + 1
timer0_fract[i] = timer0_fract[i-1] + 3
реальное Т [я] = я * 31875
если timer0_fract[i-1] >= 125:
timer0_fract[i] = timer0_fract[i-1] - 125
timer0_millis[i] = timer0_millis[i-1] + 1

скорректировано = timer0_millis*510/(256*64)

print "после 100 прерываний таймера millis() будет читать %d, фактическое значение millis равно %.6f, скорректированное значение millis равно %.6f" % (timer0_millis[99], realT[99]/1000000, скорректировано[99])
print "после 1000 прерываний таймера millis() будет читать %d, фактическое значение millis равно %.6f, скорректированное значение millis равно %.6f" % (timer0_millis[999], realT[999]/1000000, скорректировано[999])
print "после 10000 прерываний таймера millis() будет читать %d, фактическое значение millis равно %.6f, скорректированное значение millis равно %.6f" % (timer0_millis[9999], realT[9999]/1000000, скорректировано[9999])
print "после 100000 прерываний таймера millis() будет читать %d, фактическое значение millis равно %.6f, скорректированное значение millis равно %.6f" % (timer0_millis[99999], realT[99999]/1000000, скорректировано[99999])
print "после 1000000 прерываний таймера millis() будет читать %d, фактическое значение millis равно %.6f, скорректированное значение millis равно %.6f" % (timer0_millis[999999], realT[999999]/1000000, скорректировано[999999])
print "после 10000000 прерываний таймера millis() будет читать %d, фактическое значение millis равно %.6f, скорректированное значение millis равно %.6f" % (timer0_millis[9999999], realT[9999999]/1000000, скорректировано[9999999])

Благодаря ответу Эдгара и объяснению Небси о том, как именно работает счетчик, я смог придумать свою собственную реализацию того, как исправить задержку и micros(), которая пока что, кажется, отлично работает на моем Arduino Uno.

Я не говорю, что это самая точная реализация, особенно я сомневаюсь в micros(), если, например, происходит переполнение таймера между чтением t1 и t2, но пока что для меня это работает хорошо.

Во-первых, по рекомендации Эдгара я определил:

#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(1 * 512)) 

Однако это не влияет на синхронизацию micros() или delay().

Функция micros() была изменена на чтение два раза из TCNT0 — чтобы определить, идет ли счет вверх или вниз. Это делается с помощью предложения «if (t1 > t2)». Счетчик переполнения "m" умножается на 510, так как счетчик истекает после 510 шагов. Затем к этому прибавляется рассчитанное значение счетчика «t», деленное на количество тактов в микросекунде. (Примечание: Prescaler = 1, поэтому дальнейшее умножение не требуется).

unsigned long micros() {
    unsigned long m;
    uint8_t oldSREG = SREG, t1, t2;
    uint16_t t;

    cli();
    m = timer0_overflow_count;
#if defined(TCNT0)
    t1 = TCNT0;
#elif defined(TCNT0L)
    t1 = TCNT0L;
#else
    #error TIMER 0 not defined
#endif

#if defined(TCNT0)
    t2 = TCNT0;
#elif defined(TCNT0L)
    t2 = TCNT0L;
#else
    #error TIMER 0 not defined
#endif

    if (t1 >= t2) {
        t = 510 - t2;       // счетчик работает в обратном направлении
    } else {
        t = t2;             // счетчик работает вверх
    }       

#ifdef TIFR0
    if ((TIFR0 & _BV(TOV0)) && (t2 > 1))        // если установлен флаг переполнения -> увеличить м
        m++;
#else
    if ((TIFR & _BV(TOV0)) && (t2 > 1))
        m++;
#endif

    SREG = oldSREG;

    return ((m * 510) + t)  / clockCyclesPerMicrosecond();          
}

ОДНАКО - похоже, это работает нормально, но у меня были проблемы с самого начала (перед редактированием этого снова). Из-за того, что счетчик работает намного быстрее, каждые 268 секунд беззнаковый длинный тип данных micros() переполняется и снова начинается с нуля. Это приводило к нежелательной блокировке delay(), особенно если длительные задержки, как в моем случае, используются задержки в одну секунду на итерации цикла. Поэтому мне также пришлось добавить обнаружение переполнения в функцию delay() в arduino wired.c.

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

void delay(unsigned long ms)
{
    uint32_t start = micros();
    uint32_t elapsed = 0;   

    while (ms > 0) {
        yield();
        while ( ms > 0 && (micros() - 1000) >= (start + elapsed)) {         
            ms--;
            elapsed += 1000;            
        }
        if( start > micros() ) {    // обнаружено переполнение
            start = micros();       // сбросить начало
            elapsed = 0;            // сброс истек
        }
    }
}