STM32F4. RTC

[teplofizik]

В STM32, конечно же, есть контроллер часов реального времени.

Для его запуска не обязательно даже иметь внешний кварц на 32.768 кГц, так как затактировать можно от внутреннего LSI-генератора на ~32 кГц (с возможностью калибровки) или внешнего основного кварца (с настраиваемым предделителем).
А ещё, как бонус, 20 регистров (80 байт) для хранения разных данных, питание им будет идти от батарейки, от которой часы и работают, когда нет основного питания.
Возможностей у часов много, они подробно описаны в RM, остановимся пока на базовом уровне...

Основные регистры, которые надо знать, чтоб запустить RTC в минимальном режиме:
RCC_BDCR — выбор источника и включение тактирования RTC, управление внешним кварцем на 32.768 кГц;
RCC_CFGR — предделитель частоты внешнего основного кварца для RTC (чтоб на RTC шёл сигнал с частотой 1 МГц);

RTC_TR — регистр с текущим состоянием времени (запись возможна только при инициализации);
RTC_DR — регистр с текущей датой (аналогично);
RTC_CR — основная настройка режима работы часов;
RTC_ISR — регистр инициализации, с его помощью можно ввести часы в одноимённый режим;
RTC_PRER — внутренний предделитель тактовго сигнала;
RTC_CALIBR — подстройка часов (с шагом в 2 ppm в минус и 4 ppm в плюс);
RTC_WPR — разблокировка защиты от записи;

Так-то регистров там ещё много, но пока фиг с ними.

Итак, контроллер включился первый раз, все регистры часов сброшены, тактирование на модуль не поступает. Для теста попробуем включить часы от внутреннего источника тактирования LSI (на STM32F4-Discovery есть место под внешний часовой кварц, но он не распаян: X3). Конечно, при ресете, от такого источника часы накроются медным тазом, но пофиг.

1. Первым делом надо запустить внутренний генератор на 32 кГц.
В регистре RCC_CSR есть два флага: LSIRDY и LSION. Логика проста: выставляем флаг LSION, чтобы генератор завёлся, и ждём, когда он стабилизируется. Это будет показано появлением флага LSIRDY. После этого генератор можно использовать.
Для внешнего кварца логика такая же, только флаги LSERDY и LSEON находятся в регистре RCC_BDCR.
2. Регистры энергонезависимого домена (RCC_BDCR к ним относится) защищены от записи. Чтобы это исправить, надо запустить тактирование модуля управления питанием (POWER), установив флаг PWREN в регистре RCC_APB1ENR, а затем и флаг DBF (бит 8) в регистре PWR_CR. Защита отключится. Иначе можно долго гадать, какого же флаг RTCEN не хочет ставиться, когда BDRST прекрасно это делает.
3. На всякий случай сбросим состояние энергонезависимого домена, установив и сбросив флаг BDRST в том же регистре RCC_BDCR.
4. Далее включим тактирование часов (RTCCLK) от этого источника: в регистре RCC_BDCR надо выбрать источник тактирования флагами RTCSEL (биты 9-8, за LSI отвечает значение 2) и включить его флагом RTCEN (бит 15). После выбора источника тактирования часов, менять его уже нельзя, только полным сбросом домена (всё тот же BDRST).
5. Тактирование на модуль часов подано. Теперь можно их инициализировать. После запуска все важные регистры часов защищены от записи. Чтобы её отключить, надо по очереди записать в регистр RTC_WPR два числа: 0xCA и 0x53, в таком вот порядке. Запись любых иных чисел вернёт защиту снова.
6. Когда защита отключена, в регистре RTC_ISR надо установить флаг INIT (бит 7), при этом часы будут остановлены и станет возможно их значения изменить. Но сначала надо подождать установки флага INITF там же, как свидетельство готовности.
7. Дальше настраивается предделитель, который должен выдавать сигнал с частотой 1 Гц. Тут тоже хитрый процесс.
Сначала записывается значение в синхронный предделитель, потом в асинхронный. Даже если нужно установить только одно из них, актов записи должно быть два!
Для LSI синхронный предделитель равен 249, асинхронный 127. Для LSE синхронный предделитель становится 255, асинхронный такой же.
8. Часы готовы к загрузке начальных значений в регистры RTC_TR и RTC_DR. Формат времени (12/24) выбирается флагом FMT (бит 6) в регистре RTC_CR, но это по желанию и после загрузки даты и времени.
Важное замечание: загружать надо сразу весь регистр целиком! То, что будет читаться из регистра сейчас не соответствует истине (там предыдущее значение сидит, бывшее при установке флага INIT). И оно обновится только после сброса этого же флага. Все операции |= и &= на самом регистре пойдут прахом.
9. После всего этого режим инициализации отключается сбросом флага INIT и часы начинают идти. А ещё теперь в регистре RTC_ISR установлен флаг INITS, который можно проверять при запуске контроллера насчёт наличия этой вот настройки часов.
10. Ну и на всякий случай следует в конце вернуть блокировки записи и т.д.
Успех!

Читать регистры TR и DR можно уже когда угодно.

Примерный код инициализации:

void rtc_Init(void)
{
    // Включим тактирование PWR
    RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    
    // Разрешим доступ к управляющим регистрам энергонезависимого домена (для BKP)
    PWR->CR |= PWR_CR_DBP;
    
    // Если часы запущены, делать тут нечего.
    if(RTC->ISR & RTC_ISR_INITS) return;

    // Запускаем LSI:
    RCC->CSR |= RCC_CSR_LSION;
    
    // Ждём, когда он заведётся
    while(!(RCC->CSR & RCC_CSR_LSIRDY)) {}
    
    // Ок, генератор на 32 кГц завёлся.
    
    // Сбросим состояние энергонезависимого домена
    RCC->BDCR |=  RCC_BDCR_BDRST;
    RCC->BDCR &= ~RCC_BDCR_BDRST;
    
    // Выберем его как источник тактирования RTC:
    RCC->BDCR &= ~RCC_BDCR_RTCSEL; // сбросим
    RCC->BDCR |= (RCC_BDCR_RTCSEL_1); // запишем 0b10
        
    // Включим тактирование RTC
    RCC->BDCR |= RCC_BDCR_RTCEN;
    
    // Снимем защиту от записи с регистров RTC
    rtc_Unlock();
    {
        // Здесь можем менять регистры RTC

        // Войдём в режим инициализации:
        RTC->ISR |= RTC_ISR_INIT;
        
        // Ждём, когда это произойдёт
        while(!(RTC->ISR & RTC_ISR_INITF)) {}
        
        // Часы остановлены. Режим инициализации
        // Настроим предделитель для получения частоты 1 Гц.
        
        // LSI: 
        // LSE: нужно разделить на 0x7fff (кварцы так точно рассчитаны на это)
        {
            uint32_t Sync = 249;   // 15 бит
            uint32_t Async = 127;  // 7 бит
            
            // Сначала записываем величину для синхронного предделителя
            RTC->PRER = Sync;
            
            // Теперь добавим для асинхронного предделителя
            RTC->PRER = Sync | (Async << 16);
        }
        
        // Устанавливаем дату: 29.03.13, пятница
        rtc_SetDate(29, 3, 13, 5);
        
        // Устанавливаем время: 14:37:00
        rtc_SetTime(14, 37, 00);
        
        // Инициализация закончилась
        RTC->ISR &= ~RTC_ISR_INIT;
    }   
    rtc_Lock();
    
    // Всё, часы запустились и считают время.
}

Код теста:

int main(void)
{
    TDateTime DT;
    
    // Запустим RTC
    rtc_Reset();
    rtc_Init();
    
    // Инициализация GPIO
    gpio_Init();
    gpio_DigitalOutput(PORTD, 12);
    
    while(1)
    {
        rtc_Get(&DT);
        
        // Моргаем на нечётные секунды
        if(DT.Seconds & 0x01)
        {
            gpio_HighLevel(PORTD, 12);
        }
        else
        {
            gpio_LowLevel(PORTD, 12);
        }
    }
}

Проект настраивает RTC при запуске и считывает постоянно дату и время. Моргает, если секунда нечётная.

Интересные файлы:
rtc.c
rtc.h

Проект целиком.

<< Предыдущее Следующее >>