Как было упомянуто в самом первом занятии по знакомству с семейством контроллеров ESP32, данный контроллер имеет на своём борту две группы аппаратных таймеров, которые в свою очередь включают по два 64-разрядных таймера общего назначения.
Помимо 64-разрядного счётчика, каждый из 4 таймеров включает 16-разряюный предделитель и работает по простейшему принципу. Режим работы только один — режим счётчика.
Считать счётчик таймера может и в прямом и в обратном направлении. Переполнение данному счётчику не грозит, так как он 64-разрядный. При тактировании 80 мегагерц до переполнения нужно будет ждать около 60 тысяч лет. Также такой таймер можно остановить. Также значение счётчика можно прочитать и установить программно.
Как же при всех этих условиях получить срабатывание таймера?
Для этого существует регистр тревоги, значение которого как только совпадёт со значением счётчика, таймер перезагрузится и наступит событие перезагрузки, которое инициирует соответствующее прерывание.
Событие перезагрузки вырабатывается не только при равенстве значений счетчика и регистра тревоги, а также оно происходит и при превышении значением счетчика заданного порога для прямого счета и при уменьшении значения счетчика ниже порога для обратного счета. Это позволяет не пропустить событие перезагрузки в случае опоздания установки регистра тревоги по отношению к состоянию счетчика.
Вообще, регистров у таймера много, но нас они сейчас особо не волнуют, так как мы пока пользуемся библиотекой IDF, в которой есть удобный функционал управления данными регистрами и при написании кода мы в этом убедимся.
Схема останется такая же, как и в прошлом уроке
Проект был сделан из проекта урока 13 с именем SOFT_TIMER и получил имя TIMER_GROUP.
Откроем наш проект в Espressif IDF и в файле main.h вместо библиотеки
#include «esp_timer.h»
подключим вот эту
#include "driver/timer.h"
Перейдём в файл main.c и удалим функции periodic_timer_callback и oneshot_timer_callback вместе с телами.
В функции app_main удалим весь код после строки
LCD_ini();
до бесконечного цикла.
Мы будем использовать два таймера.
Для начала объявим глобальные переменные для предделителя и цены деления шкалы, которая будет зависеть от значения предделителя, а также от частоты тактирования
|
1 2 3 4 |
#include "main.h" //------------------------------------------------ #define TIMER_DIVIDER (16) // Hardware timer clock divider #define TIMER_SCALE (TIMER_BASE_CLK / TIMER_DIVIDER) // convert counter value to seconds |
Код для инициализации обоих таймеров будет подобным, поэтому мы его оформим в функцию, а не будем городить в app_main. Добавим такую функцию выше функции app_main
|
1 2 3 4 5 |
//------------------------------------------------ static void tg_timer_init(int group, int timer, bool auto_reload, int timer_interval_sec) { } //------------------------------------------------ |
Объявим и проинициализируем переменную типа структуры для конфигурации таймера
|
1 2 3 4 5 6 7 8 9 |
static void tg_timer_init(int group, int timer, bool auto_reload, int timer_interval_sec) { timer_config_t config = { .divider = TIMER_DIVIDER, .counter_dir = TIMER_COUNT_UP, .counter_en = TIMER_PAUSE, .alarm_en = TIMER_ALARM_EN, .auto_reload = auto_reload, }; |
Во входных параметрах функции будет номер группы, номер таймера, с автозапуском таймер или без, а также интервал в секундах.
Вызовем функцию инициализации таймера из библиотеки, используя идентификатор таймера из входного параметра, а также только что созданную переменную
|
1 2 3 |
.auto_reload = auto_reload, }; timer_init(group, timer, &config); |
Сбросим начальное значение счётчика в ноль
|
1 2 |
timer_init(group, timer, &config); timer_set_counter_value(group, timer, 0); |
Установим интервал срабатывания таймера
|
1 2 |
timer_set_counter_value(group, timer, 0); timer_set_alarm_value(group, timer, timer_interval_sec * TIMER_SCALE); |
Включим прерывания от таймера
|
1 2 |
timer_set_alarm_value(group, timer, timer_interval_sec * TIMER_SCALE); timer_enable_intr(group, timer); |
Объявим глобальную структуру для свойств таймера
|
1 2 3 4 5 6 7 8 9 |
} qLCDData; //------------------------------------------------ typedef struct { int timer_group; int timer_idx; int alarm_interval; bool auto_reload; } timer_info_t; //------------------------------------------------ |
Вернёмся в функцию Объявим, зарезервируем память, а также проинициализируем указатель на переменную структуры свойств таймера
|
1 2 3 4 5 6 |
timer_enable_intr(group, timer); timer_info_t *timer_info = calloc(1, sizeof(timer_info_t)); timer_info->timer_group = group; timer_info->timer_idx = timer; timer_info->auto_reload = auto_reload; timer_info->alarm_interval = timer_interval_sec; |
Выше добавим функцию-обработчик прерываний от таймера, в которой объявим и проинициализируем переменную для отслеживания состояния принудительного переключения контекста на более высокоприоритетную задачу. До вызова функции или отправки в очередь или захвата семафора ей присваивается значение pdFALSE, а после вызова — проверяется на равенство pdTRUE. Таким образом отслеживается необходимость принудительного переключения контекста
|
1 2 3 4 5 6 7 |
//------------------------------------------------ static bool IRAM_ATTR timer_group_isr_callback(void *args) { BaseType_t high_task_awoken = pdFALSE; return high_task_awoken == pdTRUE; } //------------------------------------------------ |
Смысл очереди в обработчике прерывания мы поймём немного позднее.
Вернёмся в функцию tg_timer_init и зарегистрируем функцию-обработчик прерывания для нашего таймера
|
1 2 |
timer_info->alarm_interval = timer_interval_sec; timer_isr_callback_add(group, timer, timer_group_isr_callback, timer_info, 0); |
Запустим наш таймер
|
1 2 |
timer_isr_callback_add(group, timer, timer_group_isr_callback, timer_info, 0); timer_start(group, timer); |
В функции app_main вызовем нашу функцию инициализации
|
1 2 |
LCD_ini(); tg_timer_init(TIMER_GROUP_0, TIMER_0, true, 2); |
Мы инициализируем и запускаем таймер 0 из группы ноль с автоперезагрузкой и с интервалом срабатывания в 2 секунды.
Из функции-обработчика мы будем через очередь передавать параметры таймера в обычную задачу. Это делается для того, чтобы минимизировать код в обработчике.
Поэтому объявим глобальную переменную для такой очереди
|
1 2 |
xQueueHandle lcd_string_queue = NULL; static xQueueHandle s_timer_queue; |
В функции-обработчике timer_group_isr_callback заберём указатель на переменную структуры свойств таймера из параметров
|
1 2 |
BaseType_t high_task_awoken = pdFALSE; timer_info_t *info = (timer_info_t *) args; |
Затем заберём значение счётчика в переменную
|
1 2 |
timer_info_t *info = (timer_info_t *) args; uint64_t timer_counter_value = timer_group_get_counter_value_in_isr(info->timer_group, info->timer_idx); |
Объявим ещё одну глобальную структуру для события таймера, в которую включим предыдущую, а также добавим значение счётчика
|
1 2 3 4 5 6 7 |
} timer_info_t; //------------------------------------------------ typedef struct { timer_info_t info; uint64_t timer_counter_value; } timer_event_t; //------------------------------------------------ |
Вернёмся в функцию-обработчик timer_group_isr_callback, объявим переменную типа данной структуры и заполним её значениями
|
1 2 3 4 5 6 7 8 |
uint64_t timer_counter_value = timer_group_get_counter_value_in_isr(info->timer_group, info->timer_idx); timer_event_t evt = { .info.timer_group = info->timer_group, .info.timer_idx = info->timer_idx, .info.auto_reload = info->auto_reload, .info.alarm_interval = info->alarm_interval, .timer_counter_value = timer_counter_value }; |
Если таймер без перезагрузки, то к значению, взятому из регистра счётчика, добавим интервал и занесём полученное значение в регистр срабатывания
|
1 2 3 4 5 6 |
.timer_counter_value = timer_counter_value }; if (!info->auto_reload) { timer_counter_value += info->alarm_interval * TIMER_SCALE; timer_group_set_alarm_value_in_isr(info->timer_group, info->timer_idx, timer_counter_value); } |
Отправим указатель на переменную структуры в очередь
|
1 2 3 |
timer_group_set_alarm_value_in_isr(info->timer_group, info->timer_idx, timer_counter_value); } xQueueSendFromISR(s_timer_queue, &evt, &high_task_awoken); |
Выше функции app_main добавим функцию для ещё одной задачи, в которой мы будем забирать из очереди свойства и выводить на дисплей нужные нам показатели, тем самым избавляя обработку прерывания от лишнего долго-выполняемого кода. В данной функции объявим два счётчика, два символьных массива и переменную типа структуры данных для вывода на дисплей
|
1 2 3 4 5 6 7 8 9 |
//------------------------------------------------ static void task1(void* arg) { uint16_t cnt0 = 0, cnt1 = 0; char str0[15] = {0}; char str1[15] = {0}; qLCDData xLCDData; } //------------------------------------------------ |
Объявим переменную типа структуры свойств таймера
|
1 2 |
qLCDData xLCDData; timer_event_t evt; |
Организуем бесконечный цикл, в котором попытаемся забрать указатель на переменную структуры из очереди
|
1 2 3 4 |
timer_event_t evt; for(;;) { xQueueReceive(s_timer_queue, &evt, portMAX_DELAY); } |
Присвоим полям значение горизонтальной, а также вертикальной координат вывода на дисплей строки. Значение вертикальной координаты будет совпадать с номером группы таймеров
|
1 2 3 |
xQueueReceive(s_timer_queue, &evt, portMAX_DELAY); xLCDData.x_pos = 0; xLCDData.y_pos = evt.info.timer_group; |
Затем отправим в дисплей значение счётчика в секундах
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
xLCDData.y_pos = evt.info.timer_group; if(evt.info.timer_group==0) { xLCDData.str = str0; sprintf(str0,"%5d",cnt0); xQueueSendToBack(lcd_string_queue, &xLCDData, 0); cnt0++; } else if (evt.info.timer_group==1) { xLCDData.str = str1; sprintf(str1,"%5d",cnt1); xQueueSendToBack(lcd_string_queue, &xLCDData, 0); cnt1++; } |
Такое разделение было применено из-за неуверенной работы с одним символьным массивом.
Создадим очередь в функции app_main
|
1 2 |
lcd_string_queue = xQueueCreate(10, sizeof(qLCDData)); s_timer_queue = xQueueCreate(10, sizeof(timer_event_t)); |
А затем создадим задачу
|
1 2 |
xTaskCreate(vLCDTask, "vLCDTask", 2048, NULL, 2, NULL); xTaskCreate(task1, "task1", 2048, NULL, 5, NULL); |
Соберём код, прошьём контроллер, и, если всё нормально, счётчик наш будет отсчитывать интервалы в 2 секунды
Давайте попробуем создать ещё один таймер. Для этого в функции app_main немного подождём и инициализируем, например, таймер 0 из группы таймеров 1 без перезагрузки
|
1 2 |
tg_timer_init(TIMER_GROUP_0, TIMER_0, true, 2); tg_timer_init(TIMER_GROUP_1, TIMER_0, false, 1); |
Соберём код, прошьём контроллер и увидим, что вместе с первым таймером, второй таймер во второй строке
Почему же наш второй таймер тоже считает, а не срабатывает однократно? Всё потому, что мы добавили соответствующий код в обработчике.
Давайте попробуем в функции timer_group_isr_callback данный код закомментировать
// if (!info->auto_reload) {
// timer_counter_value += info->alarm_interval * TIMER_SCALE;
// timer_group_set_alarm_value_in_isr(info->timer_group, info->timer_idx, timer_counter_value);
// }
Теперь наш второй таймер считать не будет, а сработает только один раз (отобразит нолик во вторую строку дисплея)
Давайте также посмотрим какие-нибудь параметры из нашей структуры. Только смотреть их лучше в терминале, так как дисплей не резиновый.
Выше функции vLCDTask добавим функцию по выводу значений счётчика в терминал
|
1 2 3 4 5 6 7 8 |
//------------------------------------------------ static void inline print_timer_counter(uint64_t counter_value) { printf("Counter: 0x%08x%08x\r\n", (uint32_t) (counter_value >> 32), (uint32_t) (counter_value)); printf("Time : %.8f s\r\n", (double) counter_value / TIMER_SCALE); } //------------------------------------------------ |
Мы отображаем 64-разрядное значение счётчика таймера, а затем на следующей строке вычисляем и отображаем значение в секундах.
Вернёмся в функцию task1 и отобразим в терминале сначала тип нашего таймера (с перезагрузкой или без)
|
1 2 3 4 5 6 7 |
cnt1++; } if (evt.info.auto_reload) { printf("Timer Group with auto reload\n"); } else { printf("Timer Group without auto reload\n"); } |
Далее отобразим номер таймера и номер группы
|
1 2 3 |
printf("Timer Group without auto reload\n"); } printf("Group[%d], timer[%d] alarm event\n", evt.info.timer_group, evt.info.timer_idx); |
Отобразим теперь значение счётчика, которое пришло к нам из обработчика прерывания с помощью очереди
|
1 2 3 |
printf("Group[%d], timer[%d] alarm event\n", evt.info.timer_group, evt.info.timer_idx); printf("------- EVENT TIME --------\n"); print_timer_counter(evt.timer_counter_value); |
А теперь заново извлечём из регистра значение счётчика нашего таймера и отобразим его тоже
|
1 2 3 4 |
printf("-------- TASK TIME --------\n"); uint64_t task_counter_value; timer_get_counter_value(evt.info.timer_group, evt.info.timer_idx, &task_counter_value); print_timer_counter(task_counter_value); |
Тем самым мы сможем вычислить время, за которое элемент прошел через очередь в задачу.
Пока не будем раскомментировать код перезапуска таймера, соберём код, прошьём контроллер.
Счётчик наш на дисплее также продолжает считать.
Посмотрим, что у нас в терминале
Мы видим, что таймер из группы 1 у нас сработал только 1 раз, до задачи элемент добрался примерно за 0.0045 секунды.
Первый таймер работает непрерывно. Значение счётчика у него постоянное, так как счётчик всегда обнуляется, элемент добирается до задачи примерно за 0.004 секунды.
Теперь раскомментируем тот код, который мы закомментировали.
Тогда мы получим уже вот такой результат
Таймеры работают оба, причём у таймера из группы 1 значение счётчика не сбрасывается, а постоянно наращивается.
Итак, сегодня мы познакомились с аппаратными таймерами контроллера ESP32, научились обрабатывать прерывания от них, настраивать их как с перезагрузкой, так и без таковой.
Всем спасибо за внимание!
Предыдущий урок Программирование МК ESP32 Следующий урок
Недорогие отладочные платы ESP32 можно купить здесь: Недорогие отладочные платы ESP32
Логический анализатор 16 каналов можно приобрести здесь
Дисплей LCD 20×4 можно приобрести здесь Дисплей LCD 20×4
Переходник I2C to LCD можно приобрести здесь I2C to LCD1602 2004
Смотреть ВИДЕОУРОК в YouTube (нажмите на картинку)
Смотреть ВИДЕОУРОК в Дзен (нажмите на картинку)
Добавить комментарий