Прерывания на ассемблере

Во всех главах будет одна и та же картинка регистра, поэтому сначала — как её читать. Это то же самое, что ты делал в ЛР1 с CRL, просто теперь явно.

Регистр — 32 бита, пронумерованных справа налево от 0 до 31. Четыре бита подряд — это одна шестнадцатеричная цифра, поэтому регистр — это 8 hex-цифр. Запись вида 15:12 означает «биты с 15-го по 12-й включительно» — четыре бита, одна цифра.

Подробнее про эту запись. Счёт с нуля: самый правый бит — 0, потому что его вес 2⁰ = 1, бит n весит 2ⁿ. Старший пишут первым — так же, как в любом числе старший разряд слева, и так же, как биты нарисованы на картинках регистров в RM0008: слева направо от 31 к 0. Оба конца входят: ширина поля = старший − младший + 1, у 15:12 это 4. Цифра номер k занимает биты 4k+3 : 4k, так что 15:12 — цифра 3. Внутри поля своя нумерация, тоже с нуля: в документации поле пишут как EXTI3[3:0], и его бит 0 — это бит 12 регистра. Достать значение поля: (регистр >> 12) & 0xF.

Смысл бывает у отдельного бита (тогда «бит n отвечает за n-е что-то») или у группы соседних битов — её называют полем. 1 << n — число, у которого стоит только бит n: 1 << 3 = 0x8, 1 << 10 = 0x400.

Регистр периферии — не ячейка внутри процессора, а ячейка памяти по своему адресу: процессор пишет в неё той же командой STR, что и в ОЗУ. Адрес всегда складывается одинаково — как в ЛР1, где GPIOB_BSRR = 0x4001 0C00 + 0x10:

В этой лабе блоки лежат в двух районах адресного пространства:

В ЛР1 программа сама в цикле читала IDR и сравнивала с прошлым значением — это опрос. Процессор всё время занят проверкой, а если в цикле стоит задержка, нажатие пролетает мимо: помнишь 0,75 секунды в первой версии. С прерыванием главный цикл может быть пустым — о нажатии процессору сообщит железо.

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

А решает, прерывать ли вообще, КПП — по алгоритму: принять запрос → проверить маску → определить приоритет → сформировать вектор → передать процессору. В STM32F103 таких контроллеров два: маленький (EXTI) на краю чипа и главный (NVIC) в ядре. Весь путь нажатия — это эти пять этапов и два КПП, только с конкретными адресами.

Кнопка одним концом на 3,3 В, другим — на выводе PA3. Нажатие меняет уровень на ножке с 0 на 1. Этот блок ты полностью настроил ещё в ЛР1.

Вывод настроен как в ЛР1: вход с подтяжкой вниз, тетрада 0x8. Отпущена — 0, нажата — 3,3 В перебивают подтяжку, и на ножке 1. Новое только одно: сигнал с ножки идёт не только в IDR, но и дальше, в блок, который сам умеет заметить перемену. Настраивать GPIO для этого иначе не нужно.

Следующий блок, EXTI, следит только за 16 входами, а ножек у чипа 37. Кто-то должен решить, какие ножки подключить к этим 16 входам. Это делает AFIO — тот самый блок, через который в ЛР1 освобождали PB3 от JTAG.

Правило жёсткое: линия n слушает ножку с номером n — но только одного порта. Линия 3 может слушать PA3, или PB3, или PC3, а сразу несколько — нельзя. Представь железнодорожную стрелку: пути A, B, C, D сходятся в один путь — линию 3, — и стрелка ставится четырьмя битами.

Как это разложено по регистрам — по шагам, на примере PB5:

1. Один переключатель — одна hex-цифра. Переключатель линии занимает 4 бита, то есть ровно одну цифру в шестнадцатеричной записи регистра. Что записано в цифре, тот порт и выбран: 0 — A, 1 — B, 2 — C, 3 — D.
2. В регистре — четыре переключателя. Из 8 hex-цифр регистра используются только правые четыре, левые всегда нули. Значит, один регистр обслуживает 4 линии, а для 16 линий нужно четыре регистра: EXTICR1 — линии 0–3, EXTICR2 — 4–7, EXTICR3 — 8–11, EXTICR4 — 12–15. Коротко: номер регистра = линия // 4 + 1. Линия 13: 13 // 4 = 3 → EXTICR4.
3. Какая цифра твоя. Цифры считаются справа, с нуля; первая линия регистра — в цифре 0. Поэтому цифра = линия − первая линия регистра = линия % 4. Линия 13: 13 − 12 = 13 % 4 = 1. Линия 5 в EXTICR2, который начинается с линии 4: цифра 5 − 4 = 1.
4. Записать значение. В цифру 1 пишем 1 — порт B. Регистр целиком: 0x0000 0010.

EXTICR2 = 0x 0 0 0 0   0 0 1 0
цифра:       7 6 5 4   3 2 1 0
линия:       — — — —   7 6 5 4
                             ↑ цифра 1 — линия 5, в ней 1 → порт B → PB5

Это та же арифметика, что с CRH в ЛР1: CRH хранит пины 8–15, первый у него — пин 8, поэтому PB15 лежал в цифре 15 − 8 = 7. Разница лишь в том, что в CRH заняты все 8 цифр, а в EXTICR — четыре. Почему поле 4 бита, хотя портов у твоего чипа четыре и хватило бы двух: RM0008 описывает всё семейство, у старших моделей портов до G (значения 0–6), а 4 бита — ровно одна hex-цифра. Очищать при записи всё равно нужно все 4 бита: BIC … #(0xF << сдвиг).

После сброса во всех цифрах 0 — порт A. Для PA3 и PA10 стрелка уже стоит правильно, а для PB5 её обязательно надо перевести, иначе линия 5 будет слушать PA5.

Первый этап с лекции — фиксация факта прерывания. Нажатие длится миллисекунды, а процессор может быть занят. Кто-то должен заметить перемену и запомнить её до тех пор, пока процессор не освободится. Это делает EXTI.

На ножке произошёл переход 0 → 1. Если в RTSR стоит бит этой линии, EXTI поднимает флажок — бит в PR. Флажок сам не опускается: кнопку давно отпустили, процессор занят ещё десять секунд — событие всё равно записано. Если в IMR бит линии тоже стоит, EXTI сообщает о флажке в NVIC.

EXTI реагирует на перемену, а не на состояние: пока кнопку держат, новых флажков нет. В ЛР1 ты делал это руками через BIC с прошлым состоянием — здесь детектор фронта встроен в железо.

Сравни с КПП с лекции: PR — это его регистр запросов, IMR — регистр масок. Поэтому «маленький КПП».

Все регистры EXTI устроены одинаково: бит n — линия n, по одному биту на линию (не поле, как в AFIO). Биты 0–15 — линии ножек, 16–19 — внутренние события чипа, выше — не используются.

EXTI только сообщает: «на линии 3 было событие». Прервать ли программу — решает NVIC. Это и есть контроллер приоритетных прерываний с лекции, только встроенный прямо в ядро Cortex-M3. Поэтому он описан не в документации ST, а в документации ARM (PM0056), и его адреса начинаются на 0xE000.

Отсюда главное: из всех регистров NVIC для эксперимента 1 нужен один — ISER, одна запись на кнопку (как он устроен — сразу ниже). Остальные (ICER — выключить вход, ICPR — стереть запрос, IABR — что сейчас выполняется) — кнопки пульта для особых случаев; в лабе их можно разве что посмотреть в отладчике.

У STM32F103C8 43 входа NVIC (0–42, глава 06), а в регистре 32 бита, по биту на вход. В один регистр входы не помещаются, поэтому ISER два: ISER0 — входы 0–31, ISER1 — 32–63 (у C8 заняты только его биты 0–10); в каждом бит k — вход k. Удобная особенность: запись единицы включает вход, а запись нуля не делает ничего. Поэтому ISER не надо читать и маскировать: пишешь 1 << k одной командой, соседние входы не пострадают — как с BSRR.

Почему масок две — IMR и ISER. Линии 5–9 приходят в NVIC на один общий вход 23, линии 10–15 — на общий вход 40. Выбрать среди них одну линию можно только в EXTI, а NVIC решает лишь, слушать ли вход целиком. И отличие от КПП Intel 8259 с лекции: там 1 в маске значит «запрещено», а в ISER 1 значит «разрешено».

Про каждый из своих входов NVIC хранит три вещи: разрешён ли он (бит в ISER), в каком он состоянии и насколько он важен (байт в IPR). Состояний четыре:

Главное, что следует из таблицы: запрос запоминается, даже если вход запрещён. Нажал кнопку до записи в ISER — вход 9 перешёл в «ожидает» и ждёт. Как только разрешишь его, обработчик вызовется сразу.

1. Сигнал. EXTI поднял флажок в PR — и держит на входе 9 единицу, пока флажок стоит. Это не короткий импульс, а уровень.
2. Запомнить. NVIC видит единицу на входе 9 и переводит его в pending. Разрешён вход или нет — неважно.
3. Решить. NVIC перебирает все входы в состоянии pending, которые разрешены в ISER, и выбирает самый важный (меньший номер приоритета; при равенстве — меньший номер входа). Если он важнее того, что процессор делает сейчас, — прерываем. Главную программу прерывает любой разрешённый вход.
4. Передать. NVIC сообщает ядру номер входа. Ядро сохраняет регистры в стек (глава 07), берёт адрес из строки 16 + 9 = 25 таблицы векторов (глава 08) и прыгает туда. В этот момент железо само снимает pending и ставит active.
5. Обработать. Твой код переключает светодиод и сбрасывает флажок в EXTI_PR — единица на входе 9 пропадает.
6. Вернуться. BX LR — ядро восстанавливает регистры, NVIC снимает active и ещё раз смотрит на вход: если там всё ещё единица, вход снова становится pending, и обработчик немедленно вызывается опять.

Регистры NVIC идут парами: ISER/ICER — разрешение, ISPR/ICPR — ожидание. Внутри пары хранится один и тот же набор битов, а регистры — две кнопки к нему: через S (set) единица ставит бит, через C (clear) единица снимает. Ноль в обоих ничего не делает. Прочитать можно любой из пары — оба покажут текущее состояние.

Зачем так: чтобы менять один вход одной записью, не трогая остальные. Если бы разрешение лежало в обычном регистре, пришлось бы читать → править бит → писать, и прерывание, случившееся между чтением и записью, могло бы изменить регистр — твоя запись затёрла бы его изменение. Ровно та же идея, что у BSRR в ЛР1.

Кроме масок отдельных входов у ядра есть один общий бит PRIMASK: при 1 не срабатывает ни одно прерывание с настраиваемым приоритетом, при 0 — работают все разрешённые. Меняют его командами CPSID I (запретить всё) и CPSIE I (разрешить). После сброса он равен 0, поэтому тебе ничего делать не нужно — достаточно ISER. Но если встретишь CPSID I в чужом коде — это он.

Пока нажатие идёт по чипу, у него четыре раза меняется номер. У каждого блока своя нумерация, и перевод из одной в другую делает сам блок по своему правилу. В коде нужны все четыре: номер линии — для AFIO и EXTI, номер входа — для ISER, строка — чтобы поставить DCD на нужное место, адрес — чтобы проверить себя в отладчике. Эта глава собирает все четыре правила вместе, и дальше числа для любой кнопки можно найти самому.

Правило простое: ножка с номером n идёт на линию n, какой бы ни был порт. PA3, PB3 и PC3 претендуют на одну линию 3. Кто из них её получит — решает AFIO, полем в EXTICR (глава 03).

Отсюда первое ограничение: на одной линии — одна ножка. Нельзя получить прерывания одновременно от PA5 и PB5: это одна линия 5. Зато PA3, PB5 и PA10 друг другу не мешают — у них разные номера.

Этот переход не вычисляется: какую линию к какому входу подключить, решила ST при разработке чипа. Правило берут из таблицы векторов в RM0008. У STM32F103C8 43 входа NVIC на весь чип, и почти все заняты другой периферией: таймерами, DMA, USART… Отдельные входы получили только линии 0–4. Остальные собраны в две группы.

Как читать имена EXTI9_5 и EXTI15_10. В RM0008 они расшифрованы как «EXTI Line[9:5]» и «EXTI Line[15:10]». Это та же запись диапазона, что у битов 15:12 (глава 00): сначала старший номер, потом младший, оба включены. EXTI9_5 — линии 9, 8, 7, 6, 5. В имени метки двоеточие нельзя, поэтому подчёркивание.

Правило «+6» для линий 0–4 — не закон, а следствие порядка в таблице: входы 0–5 уже заняты (WWDG, PVD, TAMPER, RTC, FLASH, RCC), и EXTI0 встал шестым. Для остальных линий: 5–9 → 23, 10–15 → 40.

Таблица векторов — это не только прерывания периферии. Первые 16 строк отведены событиям самого ядра: начальный SP, Reset, NMI, HardFault и другие, вплоть до SysTick. Входы NVIC идут после них, поэтому строка = IRQ + 16. Это и есть «16 +» с лекции: прибавляют к номеру входа, а не к номеру линии.

Ниже — таблица целиком. Серые строки — ядро, у них нет номера IRQ. Своя программа должна описать таблицу как минимум до строки самого старшего используемого входа. Для PA10 это строка 56, то есть 57 слов DCD, считая строку 0.

Каждая строка — одно слово DCD, 4 байта, таблица начинается с адреса 0. Поэтому адрес строки = строка × 4: 25 × 4 = 100 = 0x64. Этот адрес виден в Keil: окно Memory, адрес 0x08000064 (при BOOT0 = 0 флеш виден и с адреса 0, и с 0x0800 0000).

В строке лежит ровно одно: адрес обработчика, то есть метка из DCD. Одна строка — один адрес — один обработчик. Именно здесь группировка и становится заметной: у линий 0–4 по своей строке, значит по своему обработчику, а у всех линий 5–9 одна строка 39 и один обработчик на всех.

Группы есть только в NVIC и в таблице векторов. В EXTI у каждой линии по-прежнему свои биты:

NVIC решил прерывать. Чтобы после обработчика главная программа продолжилась как ни в чём не бывало, нужно отложить её контекст. У x86, который разбирали на лекциях, процессор сам сохраняет только флаги и адрес возврата, а остальное — программа. Cortex-M3 делает всё сам, без единой твоей команды.

Сохраняются именно те 8 регистров, которые по соглашениям ARM любая подпрограмма имеет право испортить. Значит, обработчик — обычная подпрограмма, при условии, что сам не трогает R4–R11: их ядро не сохраняет. Если нужны — PUSH в начале и POP в конце.

Ядро знает номер — 25, но не знает, где твой обработчик. Адрес ему подсказывает таблица векторов — «телефонная книга» в начале флеша.

Ядро берёт слово по адресу номер × 4, кладёт его в PC и оказывается в начале обработчика. Никакого кода, который разбирался бы, «кто позвал», нет — поэтому контроллер и называется векторным.

У тебя в таблице 4 строки: SP, Reset, NMI, HardFault. Строки 25 нет — но ядро всё равно пойдёт по адресу 0x64 и возьмёт то, что там лежит, то есть байты твоего же кода. Прыжок по случайному числу, HardFault.

Поэтому таблицу дописывают подряд до нужной строки: 16 системных строк, затем IRQ 0, 1, … 9. Строку нельзя пропустить: DCD кладёт слова одно за другим, и если выбросить одну, все следующие съедут на 4 байта. Для PA10 это 57 слов, до 0xE0.

Чтобы понять таблицу векторов, полезно один раз увидеть, чем вообще является прошивка. Флеш — это длинная лента пронумерованных ячеек по одному байту, начиная с адреса 0x0800 0000. Прошивка — просто то, что лежит на этой ленте. Никаких «файлов», «переменных» или «функций» там нет — только байты подряд.

Ассемблер превращает твой текст в эти байты двумя способами:

• команды — LDR, ORR, B — кодирует в машинные коды, которые процессор умеет выполнять;
• директиву DCD вообще ничем не кодирует: он берёт число и кладёт его на ленту как есть, 4 байта. Процессор эту строчку никогда не «выполняет» — она существует только как 4 байта в памяти.

Процессор не различает, где на ленте «код», а где «данные». Он просто читает. При сбросе он по правилу берёт первые 8 байт как числа: в SP — слово по адресу 0, в PC — слово по адресу 4. Дальше он идёт по адресу из PC и читает байты уже как команды. Поэтому первые слова и нужно положить именно числами, через DCD, а не командами.

Число 0x20001000 занимает 4 байта: 20, 00, 10, 00. STM32 хранит слово младшим байтом вперёд — little endian. Поэтому на ленте они лежат как 00 10 00 20, и в дампе прошивки ты видишь именно это. Читать слово надо справа налево по байтам. Когда процессор читает слово, он сам собирает байты обратно, программе об этом думать не нужно.

Reset_Handler начинается по адресу 0x0800 0010, а в таблицу попадает 0x0800 0011. Единица в младшем бите — это не часть адреса, а флаг «переходить в режим Thumb». Команды Thumb-2 всегда лежат на чётных адресах, поэтому младший бит свободен, и процессор использует его как признак режима. Cortex-M3 умеет только Thumb, так что бит обязан быть единицей — иначе HardFault. Ставит его сам ассемблер, когда видит, что метка стоит в секции кода.

Обработчик эксперимента 1 делает две вещи: опускает флажок EXTI и переключает цвет.

Флажок. Сам он не опускается. Не сбросишь — выйдешь из обработчика, NVIC тут же снова увидит запрос, и ядро снова войдёт в обработчик. Так без конца. Сбрасывают его записью числа 1 << n в EXTI_PR целиком. Лучше — в начале обработчика: запись идёт через шину несколько тактов, и если сделать её последней командой перед выходом, NVIC может ещё успеть увидеть старый запрос.

Цвет — как в финальной версии ЛР1: прочитать ODR, инвертировать бит светодиода, записать. Только теперь без проверки фронта — фронт уже поймал EXTI.

Общие входы. Обработчик PB5 вызывается от любой из линий 5–9, PA10 — от любой из 10–15. Поэтому в них сначала проверяют свой бит в EXTI_PR через TST.

Обработчик закончил — главная программа должна продолжиться с той самой команды, на которой её прервали.

Выход — обычный BX LR. Но в LR лежит не адрес, а 0xFFFFFFF9. Увидев, что в PC загружается такое число, ядро понимает: обработчик закончен. Оно достаёт из стека те 8 регистров, возвращается в режим Thread и продолжает с сохранённого PC.

Ловушка. Если в обработчике есть BL Delay — а в эксперименте 2 он будет, — BL перезапишет LR, и 0xFFFFFFF9 пропадёт. Решение — как для вложенной подпрограммы: PUSH {LR} в начале, POP {PC} в конце.

Предлагаю сначала довести до конца одну кнопку — PA3: у неё свой вход NVIC, никаких общих векторов.

Три красные строки — три шага. После каждого на стенде видно, как сигнал продвигается на блок дальше. На плате проверять удобнее точкой останова на первой строке обработчика: остановился — вся цепочка работает.

Таблицу векторов для PA10 придётся дотянуть до строки 56 — 57 слов, самая длинная часть программы. Пиши у каждой строки комментарий с адресом, чтобы сверять с Table 63.

Третий шаг алгоритма КПП — определение приоритета. В эксперименте 1 он не участвовал: главную программу прерывает кто угодно. В эксперименте 2 обработчик работает несколько секунд, и другая кнопка нажимается во время него — тогда NVIC сравнивает приоритеты.

У каждого входа — свой байт в IPR: у PA3 это 0xE000 E400 + 9 = 0xE000 E409. Из 8 бит у STM32F103 работают только старшие 4, поэтому приоритет 6 записывают как 0x60, командой STRB — один байт.

Эти 4 бита делятся на группу и субприоритет. При PRIGROUP = 5 — два бита на группу и два на субприоритет. Вытеснение возможно, только если группа пришедшего строго меньше.

В эксперименте 2 каждый обработчик зажигает свой цвет, ждёт несколько секунд и гасит. Задержка нужна, чтобы успеть нажать вторую кнопку, пока первый обработчик ещё работает. Вот что должно получиться.

Настройка GPIO, AFIO, EXTI, ISER и таблица векторов из эксперимента 1 остаются как есть. Меняется немного: в начале программы — две записи приоритетов (AIRCR и IPR), а каждый обработчик вместо «переключить цвет» делает «зажечь — подождать несколько секунд — погасить». Ниже — по шагам, в том порядке, в каком это пишется в Reset_Handler и в обработчиках.

Выбери сценарий или поменяй числа сам — схема покажет три вещи сразу: какое слово уходит в AIRCR, где в памяти лежат байты приоритета твоих трёх кнопок и как каждый байт делится на группу и субприоритет.

Одна запись слова в 0xE000 ED0C. Число берётся из таблицы PRIGROUP в главе 13: для двух бит группы и двух бит субприоритета — 0x05FA0500. Записывать целиком, без чтения и ORR: при чтении в старшей половине вернётся 0xFA05, а не ключ.

Адрес и число не помещаются в одну команду MOV, поэтому оба грузятся через LDR Rx, =…, как маски CRL в ЛР1. Делать это нужно до записи в ISER — чтобы к моменту первого нажатия всё уже было настроено.

Адрес байта = 0xE000 E400 + IRQ. Здесь IRQ — номер входа NVIC (у PA3 это 9, а не номер линии 3), и без умножения на 4: в IPR на каждый вход приходится один байт, а не слово, как в таблице векторов. Один 32-битный IPR держит приоритеты четырёх входов: вход 9 — байт 1 регистра IPR2, 0xE000 E408 + 1 = 0xE000 E409. Значение — приоритет, сдвинутый на 4: работают только биты 7:4. При PRIGROUP = 5 байт складывается так: группа << 6 | субприоритет << 4.

PRIGROUP = 5 во всех четырёх, меняются только три байта. Удобно завести три EQU и перед каждым прогоном менять только их. Буквы A/B/C — как на временных диаграммах в главе 14.

Порядок действий в каждом из трёх обработчиков:

1. Сохранить LR в стек — PUSH {LR}. Дальше будет BL Delay, а BL перезапишет LR своим адресом возврата, и EXC_RETURN потеряется.
2. Зажечь свой цвет через BSRR. Светодиод с общим анодом, поэтому «зажечь» = сбросить бит: в BSRR пишется бит n + 16.
3. Задержка на несколько секунд: число в R3 и BL Delay.
4. Погасить: в BSRR бит n.
5. Сбросить флаг в EXTI_PR записью 1 и сразу прочитать PR обратно (почему в конце — ниже).
6. Выйти — POP {PC}: в PC попадает сохранённый EXC_RETURN, и это выход из прерывания, как BX LR.

В эксперименте 1 флаг сбрасывался первым действием. Здесь удобнее сбрасывать в конце, после задержки:

• пока обработчик горит несколько секунд, дребезг этой же кнопки и повторные нажатия только снова ставят уже поднятый флаг — они поглощаются, и после выхода обработчик не запустится второй раз. Это и есть защита от дребезга для эксперимента 2, без таймеров;
• но сброс прямо перед выходом — ровно та ошибка, из-за которой у тебя на плате обработчик вызывался дважды: запись в PR не успевает дойти до EXTI к моменту возврата. Поэтому после STR в PR — LDR из PR: чтение не завершится, пока не завершится запись. Это то «ждём, пока он снимется», что написано в шаблоне методички.

Вытеснению это не мешает: флаг своей линии на чужие входы NVIC не влияет.

Дребезг никуда не делся, но стал заметнее. В лабе 1 медленный опрос его просто «не видел». EXTI же реагирует на каждый фронт за доли микросекунды, и пачка из пяти отскоков — это пять прерываний подряд. С переключением цвета это выглядит так: нажал, а цвет не изменился или мигнул, потому что переключился чётное число раз.

Только то, что встречается в лабе. Колонка «нужно» — что пишешь сам в эксперименте 1 (Э1) и 2 (Э2).

SysTick упомянут в цели работы и, скорее всего, будет на контрольной. Это 24-битный вычитающий счётчик в ядре Cortex-M3, одинаковый у всех производителей. Он считает вниз от значения LOAD до нуля, в момент нуля вызывает исключение 15 (вектор 0x3C) и перезагружается сам.

1. Peripherals → General Purpose I/O → GPIOA, строка Pins: щелчок по биту 3 — это нажатие PA3, как в лабе 1. Для прерывания важен именно переход: щёлкнуть, чтобы бит стал 1.
2. Peripherals → External Interrupt/Event Controller (окно EXTI): видно IMR, RTSR и флаги PR. После «нажатия» в PR должен встать бит линии.
3. Peripherals → Core Peripherals → Nested Vectored Interrupt Controller: таблица IRQ с колонками «разрешено», «ожидает», «активно» и приоритетами. Если флаг в EXTI есть, а здесь IRQ не разрешён — ошибка в ISER.
4. Точка останова (F9) на первой команде обработчика. Остановился — значит, вся цепочка работает.
5. Окно Registers: в обработчике LR = 0xFFFFFFF9, а в поле Mode — Handler. Это и есть доказательство «мы в прерывании».
6. Memory по адресу SP: восемь слов стек-фрейма, среди них адрес возврата.