Таймеры: частота и время

Конспект писался по прошлогодней методичке. В 2026 году вышла новая с той же таблицей вариантов: числа ниже в силе, но задания перенумерованы, а шаг 1 перенастройки частоты расписан подробнее. Что поменялось — глава «Методичка 2026».

Первые два эксперимента — это одна и та же программа, у которой меняется источник «тиков».

• Эксперимент 1. При старте программа переводит чип с внутреннего генератора HSI на кварц HSE и получает из него частоту AHB 18 МГц. По пути ни одна частота не должна превысить свой предел: 72 МГц для SYSCLK, AHB и APB2, 36 МГц для APB1 (задание 1). Потом она бесконечно передаёт светодиодом код Морзе — своё имя и номер в группе, точка 0,5 с. Время отмеряют прерывания системного таймера SysTick (задание 2).
• Эксперимент 2. То же сообщение, но прерывания раз в 100 мс даёт TIM1 с предделителем и режимом счёта из варианта (задание 3).

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

1. Частота 18 МГц — главы 02–05. Проверка: значение RCC_CFGRc в отладчике.
2. Светодиод — глава 06. Проверка: зажигается и гаснет записью в BSRRc.
3. SysTick на 0,5 с — глава 07. Проверка: ровное мигание, 20 переключений за 10 с.
4. Код Морзе — глава 08. Проверка: передача совпадает со шкалой в этой главе.
5. Эксперимент 2 — главы 09 и 10: тик даёт TIM1, логика Морзе не меняется.

Глава 01 — общая теория таймеров, она нужна для защиты и для понимания глав 07 и 09. Глава «Си» — как записывать всё это на Си: проект, регистры, биты, ожидание, данные, обработчики.

12 октября 2026 года вышла новая методичка ЛР3: 21 страница, в сборнике это страницы 63–83. Конспект писался по прошлогодней, поэтому здесь сверка: что изменилось, что из уже написанного кода годится и чего в нём не хватает. Таблица вариантов не изменилась ни в одной строке (стр. 83), так что все числа варианта 8 в конспекте остаются в силе.

Эксперимент 2 по содержанию — прошлогодний эксперимент 1: частота по варианту и Морзе на SysTick. Свой __main в нём отдельно не требуется: он относится к устройству проекта с эксперимента 1. Поэтому обработчик Морзе можно сдавать как есть, а частоту нет. Задание 4 теперь проверяет шаг 1 по подпунктам, а в lab3.c работает только строка HPREc /4 поверх SystemInit. Полный блок перенастройки стоит в комментарии.

Прямо методичка этого не решает. В эксперименте 1 подключается только CMSIS → CORE (рис. 31, стр. 73), а пункт Device на скриншоте свёрнут. Ссылку на SystemInit из шага 1 убрали и расписали сброс по подпунктам: его ждут от тебя. Сейчас в lab3.uvprojx подключён Device:Startup, то есть SystemInit вызывается.

В ЛР1 и ЛР2 время отмерял процессор: крутил SUBS/BNE и больше ничего не делал. Таймер — отдельный блок, который считает такты сам, параллельно с программой, и в нужный момент поднимает флаг или вызывает прерывание. Процессор в это время свободен. На лекции таймеры названы устройствами, которые позволяют реализовывать такие функции, как «отсчет временных интервалов, измерение длин импульсов, формирование периодических сигналов с заданной скважностью (ШИМ), подсчет событий на входе таймера» (лекция 08, слайд 2) — ровно эксперименты 1–5 ЛР3.

На лекции таймеры STM32 делятся на четыре вида: SysTick, базовые, универсальные (в RM0008 — general-purpose, «общего назначения») и расширенные (advanced-control). Три последних вкладываются друг в друга по возможностям: функционал базового таймера есть во всех, универсальный — это базовый плюс каналы ввода-вывода, расширенный — универсальный «со всеми возможностями + еще чуть-чуть» (лекция 08, слайд 10). Поэтому, разобравшись с базовой частью один раз (ниже, «Как любой таймер отмеряет время»), ты разобрался с ней у TIM1, TIM2, TIM3 и TIM4 сразу.

SysTick в эту схему вложений не входит. Он не периферия ST, а часть ядра Cortex-M3: описан не в RM0008, а в PM0056, у него нет ни предделителя, ни ARRc, ни события обновления.

Базовый прямоугольник целиком вне зоны: отдельного базового таймера на нашем чипе нет. Но всё, что он умеет, умеют TIM1–TIM4 — они лежат в больших прямоугольниках, которые его содержат. То же с TIM5 и TIM9–TIM14: их нет, а их возможности есть у TIM2.

Что значит «high-density» и «XL-density». RM0008 описывает сразу всё семейство STM32F10x и делит его по объёму флеш-памяти: low — 16–32 КБ, medium — 64–128 КБ, high — 256–512 КБ, XL — 768 КБ – 1 МБ, плюс connectivity line — STM32F105/107. Чем больше чип, тем больше в нём периферии. Наш STM32F103C8 — medium density, поэтому TIM5, TIM6, TIM7, TIM8 и TIM9–TIM14 в нём просто не распаяны: это отдельные таймеры других, более крупных STM32, а не функции, которых не хватает нашему. Например, TIM8 — точная копия TIM1 (у них общая глава RM0008), просто второй экземпляр.

Таблица — по даташиту нашего чипа DS5319, стр. 17. Сторожевые таймеры (IWDG, WWDG) тоже считают, но их работа — перезагрузить зависшую программу; в ЛР3 они не нужны и в схему не попали.

Всё, что умеют таймеры в ЛР3, держится на одной схеме. На вход приходит тактовая частота. Делитель уменьшает её. Счётчик считает получившиеся тики до заданной границы, на границе начинает заново и поднимает флаг — это событие. Если прерывание разрешено, флаг вызывает обработчик.

На стенде справа эта цепочка нарисована целиком — от кварца до светодиода — и работает в реальном времени. Блоки 5–6 — сам таймер, флаг и светодиод: переключи SysTick или TIM1 и посмотри, как меняются делитель, счётчик и флаг; нажми на блок — под схемой откроется его регистр.

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

Для 100 мс в эксперименте 2 нужно 1 800 000 тактов по 18 МГц — в 16 бит TIM1 они не помещаются. Поэтому частоту сначала делят: предделитель — это ещё один маленький счётчик перед основным. Он считает входные такты до N и на каждом N-м такте даёт основному счётчику один тик. Основной счётчик видит уже 18 МГц / N.

Так время раскладывается на два множителя: предделитель задаёт «цену» одного тика (при N = 9000 — 0,5 мс), а граница ARRc — сколько тиков отсчитать (200 тиков по 0,5 мс = 100 мс). У SysTick полноценного предделителя нет, есть только выбор «делить на 8 или нет»; для точки 0,5 с хватает и этого — глава 07.

В ЛР1 и ЛР2 ты сам складывал базу и смещение, писал тройки LDR → операция → STR, следил за R0–R3 и заполнял таблицу векторов. На Си это делает компилятор. За тобой остаётся то же, что и было главным: какие регистры, какие биты и в каком порядке. Главы 02–10 описывают именно это. Здесь — как их записать.

Примеры ниже нарочно на соседних регистрах — порт A, генератор LSI, TIM2. Программу ЛР3 из этих приёмов собираешь ты. Подробнее, с дизассемблером и сравнением с твоим ассемблером, — в отдельном конспекте «Си для STM32F103», но для ЛР3 достаточно этой главы.

Новый проект в Keil: Project → New µVision Project, устройство STM32F103C8. В окне Manage Run-Time Environment отметить CMSIS → CORE и Device → Startup — Keil сам добавит стартовый файл и system_stm32f10x.c. Потом Add New Item → C File → main.c. Собрать — F7, прошить — tools/flash-keil, как в ЛР2. Через make — Makefile из одной строки include ../tools/rules-c.mk.

После сброса порядок такой: Reset_Handler → SystemInit() → служебная __main (обнуляет глобальные переменные) → твоя main(). Самый маленький main.c:

В stm32f10x.h каждый блок периферии описан как структура — список регистров в том порядке, в каком они лежат в памяти, по 4 байта на регистр. Имя блока — указатель на структуру по базовому адресу. Поэтому TIM2->ARR — это регистр по адресу база TIM2 + смещение ARRc, ровно как в таблице регистров RM0008. Стрелка -> читается «поле структуры, на которую указывает указатель».

Имена битов и полей устроены по схеме БЛОК_РЕГИСТР_ПОЛЕ, как в RM0008: RCC_CR_HSERDY — бит HSERDYc регистра RCC_CRc. У полей есть два вида имён: маска всего поля (RCC_CFGR_HPRE = 0x000000F0) и готовые значения (RCC_CFGR_HPRE_DIV2 = 0x00000080). Маской очищают, значением записывают. Маску можно писать и числом: 1u << 9, 0x7u << 24. Буква u делает число беззнаковым — со сдвигом на 31 бит без неё в Си выходит неопределённое поведение.

Каждая твоя ассемблерная тройка — одна строка. Компилятор сам развернёт её в те же команды.

Поле — несколько бит с одним смыслом: делитель, множитель, режим вывода. Просто |= только добавляет единицы и не убирает старые, поэтому поле сначала очищают маской, потом вставляют значение.

Обычно годится любой вариант. Но если ноль в поле что-то значит, пиши одной строкой. Например, в поле SWc регистра RCC_CFGRc код 00 — это «переключиться на HSI», и двухстрочная запись на мгновение именно это и попросит.

«Дождаться готовности» из методички — пустой цикл, который крутится, пока условие не выполнится. Фигурные скобки пустые: делать нечего, только проверять.

Как читать последнюю строку. Имена в ней — просто числа. В stm32f10x.h они заданы через #define: RCC_CFGR_MCO = 0x0F000000 — маска поля MCO, единицы ровно на месте поля; RCC_CFGR_MCO_SYSCLK = 0x04000000 — код 0100, уже сдвинутый на место поля. Перед компиляцией вместо имён подставляются эти числа, и компилятор видит while ((RCC->CFGR & 0x0F000000) != 0x04000000) { }.

На каждом круге цикл делает три вещи. Читает регистр: RCC->CFGR — это адрес 0x4002 1000 + 4, а регистры объявлены volatile, поэтому он читается заново каждый раз. Обнуляет & всё, кроме поля, чтобы соседние поля не мешали сравнению. Сравнивает остаток с нужным кодом: не равно — ещё круг. Это тот же цикл, что ты писал на ассемблере:

Поле сравнивают целиком, а не по одному биту: у поля несколько кодов, и только полное совпадение однозначно говорит, какой из них сейчас записан. Число за любым именем показывает метка c рядом с именем в главах 02–10, а в Keil — правый клик по имени → Go To Definition.

Типы с размером в имени: uint32_t — 32 бита без знака (слово, как DCD), uint16_t и uint8_t — 16 и 8. Регистры периферии — 32-битные.

volatile запрещает компилятору выбрасывать или объединять обращения к переменной. Он нужен, когда значение меняется «само»: так объявлены все регистры в заголовке. И так же нужно объявлять переменную, которую меняет обработчик прерывания, а читает main. Без volatile main прочитает её один раз и дальше будет работать со старым значением.

Массив нумеруется с нуля, длину знает sizeof. Строка — массив символов, который заканчивается нулевым байтом '\0'; по нему цикл понимает, что строка кончилась. Символ в Си — это просто число (код ASCII), и буквы идут подряд, поэтому c - 'A' превращает букву в её номер — удобный индекс в таблицу. const у данных кладёт их во флеш, а не в ОЗУ.

Если элемент данных — не одно число, а несколько связанных, их объединяют в структуру:

Функция без результата объявляется как void имя(void). Если вынести каждый шаг настройки в свою функцию, main читается как план из главы 00, а ошибку легче локализовать: можно временно закомментировать один вызов. Функцию надо определить выше места вызова (или объявить заранее).

В стартовом файле каждая строка таблицы векторов уже ссылается на имя, например DCD TIM2_IRQHandler, и все эти имена объявлены «слабыми»: пока ты не написал функцию с таким именем, строка ведёт в заглушку Default_Handler — бесконечный цикл. Написал функцию — компоновщик подставит её. Считать строки таблицы больше не нужно.

Внешнему прерыванию нужно ещё разрешение в NVIC — функция CMSIS NVIC_EnableIRQ(номер), номера вида TIM2_IRQn лежат в заголовке. SysTick — исключение ядра, ему NVIC не нужен. Регистры R0–R3 и R12 компилятор, как и ты в ЛР2, использует свободно, а остальные сам сохранит в стеке, если понадобятся.

Таймер ничего не знает о секундах — он считает такты. Сколько тактов в секунде, решает цепочка делителей и умножителей от генератора до таймера. Поэтому задание 1 стоит первым: пока частота не известна точно, ни SysTick, ни TIM1 не отмерят 0,5 с.

Требований три, и все записаны прямо в методичке:

1. Частота AHB — по варианту. Так сказано в задании 1 стр. 8. В таблице вариантов (стр. 12) у варианта 8 в столбце «Частота AHB, МГц» стоит 18.
2. Источник — кварц через PLL. Так требуют введение к заданию стр. 5 и шаг 4 стр. 7.
3. Нигде не превысить предел. Задание 1 ограничивает все частоты 72 МГц стр. 8. У шины APB1 по RM0008 предел ниже — 36 МГц.

Частота AHB не задаётся одним числом: её дают генератор, умножитель, переключатель и делитель, и чтобы получить 18 МГц от кварца, надо понимать, как они связаны.

Дерево тактирования легче понять не как цепочку, через которую частота проходит целиком, а как несколько дорог и один переключатель между ними. Генераторы и умножитель — только кандидаты: каждый можно включить, настроить и дождаться его готовности, но частота ядра от этого не меняется. Решает переключатель SWc. Всё, что стоит после него, только делит частоту. Ниже это разобрано по порядку; каждую ситуацию кнопка ставит на стенде справа, а клик по блоку стенда открывает его регистр.

Исходное положение. После сброса ядро работает от HSI — генератора внутри чипа на 8 МГц RM0008, стр. 97. Кварц и умножитель выключены. Так работали ЛР1 и ЛР2. В проекте Keil до main ещё успевает отработать SystemInit и меняет эту картину — к этому вернёмся в главе 05.

Включить генератор — ещё не подключить его. Кварцевый генератор HSE запускают битом HSEONc. Частоту он даёт не сразу: кристаллу нужно время раскачаться, и пока колебания не станут стабильными, железо держит бит готовности HSERDYc = 0. Но и готовый HSE ни к чему не подключён — ядро продолжает работать от HSI. Включённый генератор лишь становится доступен тем, кто стоит дальше: умножителю и переключателю.

Переключатель SWc решает, от чего работает ядро. Это поле регистра RCC_CFGRc, и входов у него три RM0008, стр. 92: HSI, HSE и PLL. Первые два — генераторы напрямую, ровно 8 МГц, без деления и умножения. Третий — выход умножителя PLL. То, что выбрано в SW, и становится системной частотой SYSCLK.

Переключатель не даст ядру остаться без частоты: он переходит только на готовый источник, а если выбран неготовый — ждёт, пока тот заработает RM0008, стр. 97. Поэтому записать SWc мало: что выбрано на самом деле, показывает соседнее поле SWSc, и его дожидаются.

PLL — отдельная дорога, а не ступень на пути. Напрямую получается только 8 МГц; любую другую частоту даёт третий вход — PLL. У этой ветки свой вход, и выбирают его два переключателя по очереди. PLLSRCc решает, какой генератор подать: HSI или HSE. HSI в PLL всегда приходит поделённым на 2 (4 МГц) — этот делитель не настраивается. Если выбран HSE, второй бит, PLLXTPREc, решает, подать его целиком (8 МГц) или пополам (4 МГц); на ветку HSI он не влияет. Поэтому HSI без деления попадает в систему только напрямую, через SWc = 00 RM0008, стр. 95. Вход PLL умножает на целое число PLLMULc — от 2 до 16.

У PLL строгий порядок: настроить, включить, дождаться, выбрать. Вход и множитель задают, пока PLL выключен; после включения их уже не поменять RM0008, стр. 96. Потом PLLONc = 1 — и, как кварцу, PLL нужно время, чтобы подстроить выход под вход (в RM0008 это называется «PLL locked»); готовность показывает PLLRDYc. И даже готовый PLL ничего не переключает: его выход просто появляется на третьем входе SWc. Ядро перейдёт на него только после записи SW = 10.

Занятый источник не выключить. Пока источник питает ядро — напрямую или через PLL, — остановить его нельзя RM0008, стр. 97. Запись PLLONc = 0 или HSEONc = 0 в этот момент просто не выполнится. А раз работающий PLL не выключить, то и множитель его не поменять. Отсюда первый шаг перенастройки в главе 05: увести ядро на HSI и только потом трогать PLL. На стенде это видно, если при включённом SWc = PLL нажать на PLL: стенд откажет и подсветит, что выставить сначала.

После переключателя — только деление. У делителей нет бита включения и флага готовности: записал код — деление сразу другое. HPREc делит SYSCLK для шины AHB; получается HCLK — на ней работают ядро, память и SysTick, это и есть «частота AHB» из варианта. PPRE1c и PPRE2c делят HCLK для шин периферии APB1 и APB2. Таймер берёт частоту своей шины, а если её делитель не 1 — удвоенную (TIMxCLK). Пределы — 72 МГц для AHB и APB2, 36 МГц для APB1.

Что из этого собирает вариант 8. Включить кварц и дождаться HSERDYc → подать на PLL HSE / 2 = 4 МГц → умножить на 9, получится 36 МГц → включить PLL и дождаться PLLRDYc → SWc = PLL, SYSCLK = 36 МГц → HPREc = 2, AHB = 18 МГц. Почему именно 4 × 9 и деление на 2 — глава 03; в каком порядке писать это в регистры, когда программа уже работает от PLL, — глава 05.

Та же цепочка, но с переключателями: меняй источник, множитель и делители, и схема пересчитается сразу. Красным — то, что нарушает пределы RM0008; под схемой — что записать в регистры для выбранной настройки. Кнопка «После SystemInit» показывает, с чего начинает программа в Keil.

Число 18 МГц задано вариантом (глава 02). Выбирать надо не частоту, а способ её получить. Рассуждение в три шага.

1. Что может выдать PLL. Вход PLL — ветка HSE, то есть 8 МГц (PLLXTPREc = 0) или 4 МГц (PLLXTPRE = 1). PLLMULc — целое от 2 до 16, выход — не больше 72 МГц:

Все числа кратны 4, и 18 среди них нет. Поэтому просто «включить PLL на 18» невозможно.

2. Чем можно поделить. После переключателя стоит делитель HPREc: HCLK = SYSCLK / HPRE, где HPRE — 1, 2, 4, 8, 16… Значит, SYSCLK должна быть равна 18 × HPRE: 18, 36, 72, 144… 18 PLL не даёт, 144 больше предела, остаются 36 и 72.

3. Итого — ровно два способа:

Обе правильные. На защите спросят не какую ты выбрал, а почему без делителя AHB 18 МГц не получить. Дальше в конспекте везде вариант A: у него меньше тактов ожидания флеша (глава 04), и именно он проверен на твоей плате. Где у варианта B другие числа, они даны в скобках.

Делители APB вариант не задаёт. После SystemInit PPRE2c = /1, а PPRE1c = /2. С нашей AHB это значит APB2 = 18 МГц и APB1 = 9 МГц — оба в пределах нормы, так тоже правильно. В конспекте обе ставим /1 ради простоты: все шины по 18 МГц, правило удвоения для таймеров не участвует. Главное для эксперимента 2 в любом случае выполняется: TIM1 тактируется ровно 18 МГц.

Флеш-память читается медленнее, чем умеет ядро на высокой частоте. Чтобы ядро не получило недочитанную команду, в FLASH_ACR задают число тактов ожидания (LATENCYc). Важная деталь: считается оно от SYSCLK, а не от частоты AHB.

Отсюда «1 такт» у варианта A (SYSCLK 36) и «2 такта» у варианта B (SYSCLK 72), хотя HCLK у обоих 18. Второе правило — про буфер предвыборки (prefetch): он обязан быть включён при любом делителе HPREc, кроме /1, то есть при /2, /4, /8 … /512 RM0008, стр. 59. При /1 он может быть и выключен. У нас HPRE = /2, значит буфер нужен. После сброса он и так включён, и трогать его не стоит: включать и выключать буфер разрешено только при SYSCLK ниже 24 МГц и HPRE = /1 RM0008, стр. 59.

Порядок важен: LATENCYc выставляется до переключения на быструю частоту. Если переключиться раньше, первые же команды прочитаются из флеша с ошибками.

В проекте Keil на Си к началу main частота уже не 8 МГц. Стартовый файл до main вызывает SystemInit (конспект по Си, глава 07), и она оставляет вот что:

Обязательно меняются SYSCLK, HPREc и LATENCYc (последнее — шагом 2 методички); делители APB — по желанию (глава 03). И начинать нужно с того, что ядро работает от того самого PLL, который мы собираемся менять.

Вся перенастройка — это два регистра блока RCC. RCC_CRc включает генераторы и PLL и сообщает, готовы ли они. RCC_CFGRc выбирает источники, делители и множитель.

Шаги — из методички, в её порядке. В последнем столбце — почему шаг стоит именно здесь.

Дождаться — пустой цикл, пока бит готовности не примет нужное значение (приём «ждать» в главе Си). Поле SWSc сравнивают целиком: выделить маской RCC_CFGR_SWS и сравнить с RCC_CFGR_SWS_PLL — со скобками вокруг выделения.

Перед записью поля его очищают маской (приём «поле» в главе Си), как ты делал с CRL в ЛР1. Поле SWc пиши одной записью: промежуточный 00 — это «переключиться на HSI». После SystemInit в полях лежат старые значения, и простое |= только добавляет единицы, но не убирает их. Пример: в PLLMULc лежит 0111 (×9), записываем 0110 (×8) — получится 0111 | 0110 = 0111, то есть снова ×9. А PPRE1c = 100 (/2) без очистки так и останется /2.

Морзе передаём одним цветом RGB-светодиода. Вывод нужно подготовить так же, как в ЛР1: включить тактирование порта, перевести вывод в режим выхода и дальше управлять им через BSRRc. Разница с ЛР1 одна — теперь пишем на Си.

1. Тактирование порта B: бит IOPBENc в RCC_APB2ENRc (RCC_APB2ENR_IOPBEN). Без него запись в регистры GPIOB игнорируется.
2. Режим вывода: в GPIOB_CRHc четыре бита пина 15 — MODE15c = 10 (выход, 2 МГц) и CNF15c = 00 (двухтактный), то есть 0010. Остальные пины не трогать: очистить четвёрку маской GPIO_CRH_MODE15 | GPIO_CRH_CNF15 и записать GPIO_CRH_MODE15_1.
3. Сразу погасить: записать в BSRRc GPIO_BSRR_BS15. После сброса в ODR лежит 0, поэтому сразу после настройки режима светодиод с общим анодом загорается.

SysTick — 24-битный счётчик внутри ядра Cortex-M3. Он считает вниз от числа LOADc до нуля, на нуле перезагружается и, если разрешено, вызывает исключение SysTick_Handler (строка 15 таблицы векторов — та, что у тебя в ЛР2 была заглушкой). Если настроить его на одну «точку» кода Морзе, всё остальное — просто счёт тиков.

При AHB/8 было бы 1 125 000 тактов (LOADc = 1 124 999), но вариант требует AHB. А вот при 72 МГц точка 0,5 с — 36 млн тактов — в 24 бита уже не влезает: это ещё одна причина сначала выполнить задание 1.

Когда настраивать: после задания 1. LOADc посчитан для 18 МГц; если включить SysTick раньше, первые тики пойдут на 72 МГц.

Порядок: записать LOADc, обнулить VALc (любой записью), затем в CTRL одной записью CLKSOURCEc = 1, TICKINTc = 1, ENABLEc = 1. На Си регистры называются SysTick->LOAD, SysTick->VAL, SysTick->CTRL, маски битов — SysTick_CTRL_CLKSOURCE_Msk, SysTick_CTRL_TICKINT_Msk, SysTick_CTRL_ENABLE_Msk (core_cm3.h).

Как устроена запись в CTRL. В CTRL всего четыре бита, и три из них ставит программа (картинка регистра ниже). Каждая маска — просто число с одной единицей на месте своего бита: ENABLEc = 0x1 (бит 0), TICKINTc = 0x2 (бит 1), CLKSOURCEc = 0x4 (бит 2). Операция | складывает их в одно число 0x7 — «все три бита в 1». Записывают его через =, а не |=: весь регистр наш, остальные биты либо зарезервированы, либо только для чтения (COUNTFLAGc), так что читать старое значение незачем. Все три бита идут одной записью и последними: как только ENABLE станет 1, счёт пойдёт от того, что лежит в LOADc и VALc, поэтому они должны быть готовы заранее. Если по ошибке написать & вместо |, получится 0 — у масок нет общих единиц, и SysTick не запустится.

Обработчик — функция void SysTick_Handler(void) ровно с таким именем: под это имя в стартовом файле уже отведена строка 15 таблицы векторов. NVIC включать не нужно: SysTick — исключение ядра, а не внешнее прерывание. Флаг сбрасывать тоже не нужно.

CMSIS-функция SysTick_Config(ticks) делает то же самое и вдобавок ставит SysTick самый низкий приоритет. Но в LOADc она пишет ticks − 1, поэтому передавать ей надо 9 000 000, а не 8 999 999.

В методичке таблица только латинская (стр. 7). Если хочешь передавать имя по-русски, нужна русская азбука Морзе — она общепринятая, но в материалах курса её нет, поэтому сначала спроси преподавателя, засчитают ли так. Большинство русских букв передаётся тем же кодом, что и латинская «пара» (справа в клетке); своего латинского двойника нет только у Ч, Ш, Ъ, Э, Ю, Я. Ё передают как Е.

Впиши своё сообщение латиницей, кириллицей или цифрами — сейчас там пример IVAN 8. Шкала покажет, когда горит светодиод и сколько длится один цикл передачи. По ней же потом сверяешь плату. Это же сообщение мигает светодиод на стенде справа.

Программа делится на три части, и у каждой одна задача.

1. Данные — что передавать. Сообщение раскладывается в последовательность элементов «уровень + длительность в точках»: горит 1, не горит 1, горит 3, не горит 3… Например, IE = горит 1, не горит 1, горит 1, не горит 3, горит 1, не горит 7, и сначала. Последовательность можно один раз построить в main из строки и таблицы кода, а можно записать вручную. Построить из строки надёжнее: меньше мест для опечатки, и легко поменять сообщение.
2. Обработчик — когда переключать. Вызывается на каждый тик. Уменьшает счётчик «тиков осталось». Когда тот дошёл до нуля, переходит к следующему элементу (после последнего — к первому), выставляет светодиод по его уровню через BSRRc (глава 06) и загружает «тиков осталось» = длительность × тиков на точку.
3. main — порядок запуска: частота (глава 05) → светодиод (глава 06) → последовательность → выставить светодиод по первому элементу → таймер (глава 07). После этого — пустой бесконечный цикл, вся работа идёт в обработчике.

Тиков на точку — единственное, что отличает эксперимент 2: у SysTick тик равен точке, значит 1. У TIM1 тик 100 мс, значит 5. Если сразу вынести это число в константу, эксперимент 2 не потребует трогать логику Морзе.

Обработчик короткий и ничего не ждёт в цикле — в этом и смысл задания по сравнению с задержками ЛР1. Переменные, которые меняет обработчик, объявляются volatile (конспект по Си, глава 04).

Вариант 8 задаёт TIM1 в центрированном режиме. На лекции он описан как счёт от ARRc до нуля и обратно лекция 08, слайд 18. Но для расчёта периода важна точная формулировка RM0008: счётчик идёт от 0 до ARR − 1, на этом — переполнение, потом от ARR вниз до 1, на этом — переполнение снизу, и снова с нуля. Полный цикл — 2 × ARR тиков, а событие обновления бывает на обоих концах, то есть каждые ARR тиков. Это я проверил на твоей плате.

CMSc = 01, 10 или 11 — три центрированных режима — отличаются только тем, когда ставятся флаги каналов (на счёте вниз, вверх или в обе стороны). Для периода и события обновления они одинаковы; в варианте указано «Ц» — подойдёт любой, например 01. В центрированном режиме бит направления DIRc только читается: таймер меняет его сам.

Счётчик повторений RCRc (есть у TIM1, нет у TIM2–4): событие обновления выдаётся не на каждом переполнении, а на каждом (RCR + 1)-м. В центрированном режиме RCR уменьшается и на переполнении, и на переполнении снизу — поэтому RCR = 1 даёт ровно одно событие на полный цикл вверх-вниз. Попробуй на шкале.

PSCc и ARRc, которые ты пишешь, — «предварительные» регистры. Таймер работает по их теневым копиям, а копирование происходит по событию обновления:

• PSCc всегда применяется только на следующем UEV. Если просто записать PSC = 8999 и включить таймер, первый период пройдёт со старым предделителем 0 — в 9000 раз быстрее;
• ARRc — сразу, если ARPEc = 0, или на следующем UEV, если ARPE = 1 (бит в TIMx_CR1).

Чтобы новые значения применились сразу, после настройки генерируют событие обновления программно: бит UGc в TIMx_EGR. Но у него побочный эффект — он ставит UIFc, и если прерывание уже разрешено, обработчик вызовется сразу, «на нулевой секунде». Поэтому порядок: PSCc, ARRc → UG → сбросить UIF → разрешить UIEc и включить счёт (CENc). Есть и второй путь — бит URS в CR1: с ним UG обновляет регистры, но UIF не ставит.

Задание 3 — то же сообщение, но тик раз в 100 мс даёт TIM1 с предделителем 9000 и центрированным счётом. Последовательность и логика обработчика из главы 08 остаются; меняются настройка таймера, имя обработчика и «тиков на точку» — 5 вместо 1.

Почему 200, а не 199, — глава 09: в центрированном режиме событие приходит и на вершине, и внизу, то есть каждые ARRc тиков, а не ARR + 1.

Обработчик называется TIM1_UP_IRQHandler, не TIM1_IRQHandler: у TIM1 четыре входа NVIC, и событию обновления отвечает TIM1_UPc (глава 01). Первым делом в нём сбрасывают UIFc записью нуля (глава 09). Если флаг не сбросить, обработчик будет вызываться снова и снова, как с EXTI_PR в ЛР2. Потом — тот же тик Морзе.

Вопросы по экспериментам 1 и 2 — с короткими ответами и ссылкой на главу. Как с равными приоритетами в ЛР2: ответ «на глаз» часто неверный, а правильный следует из одной строки документации.

Подробные главы появятся, когда откроют ЛР3. Но три вещи стоит знать заранее: каждая влияет на то, как собирать стенд.

• Эксперимент 3, захват — кнопку придётся перенести. Длительность нажатия меряют режимом «PWM input»: два канала от одного входа, и фронт входа сбрасывает счётчик. Источник сброса выбирает поле TS регистра TIM1_SMCR, а оно умеет только TI1FP1 и TI2FP2 — входы каналов 1 и 2. Значит, кнопка должна стоять на PA8 (CH1) или PA9 (CH2), а не на PA10 (CH3).
• Эксперимент 4, ШИМ — светодиод придётся перенести, а методичка описывает PWM1 наоборот. Каналы 1–3 TIM1 — это PA8, PA9, PA10, и RGB надо переключить на них. В методичке сказано, что в PWM1 выход равен 0, пока счётчик меньше CCR. По RM0008 наоборот: канал активен, пока счётчик меньше CCR1 RM0008, стр. 350. С общим анодом активный уровень гасит светодиод, поэтому яркость будет обратной заполнению. Кроме того, при предделителе 9000 у ШИМ либо мало ступеней яркости, либо заметное мерцание — это и есть доказательство, которого методичка требует, чтобы разрешить уменьшить предделитель.
• Эксперимент 5, энкодер и сервопривод — нужны железо и второй таймер. Энкодер подключается к каналам 1 и 2; режим 2 варианта — это SMS = 010. Счётчик в режиме энкодера занят целиком, так что ШИМ для сервопривода (период 20 мс, импульс 0,5–2,5 мс) придётся формировать на другом таймере. Выход — толерантный к 5 В, в режиме open-drain; питание сервопривода — 5 В от программатора. Проверь заранее, есть ли у тебя энкодер и сервопривод.