\documentclass[a4paper,fontsize=14bp]{article}

\author{Выхованец Валерий Святославович}
\title{Микропроцессорные устройства обработки сигналов}
\date{2022-02-11}

\input{../common-preamble}
\input{../fancy-listings-preamble}
\input{../bmstu-preamble}
\numerationTop
\usepackage{subfiles}
\newcommand\ver[1]{\rotatebox{90}{#1 }}

%% This code creates the groups
% -----------------------------------------
\usepackage{etoolbox}
\renewcommand\nomgroup[1]{%
  \item[\bfseries
    \ifstrequal{#1}{C}{Общие}{%
      \ifstrequal{#1}{A}{Применение}{%
        \ifstrequal{#1}{P}{Процессор}{%
          \ifstrequal{#1}{M}{Память}{%
            \ifstrequal{#1}{I}{Ввод-вывод}{%
              \ifstrequal{#1}{O}{Прочие}{}
    } } } } }%
  ]
}
% -----------------------------------------

\begin{document}
\maketitle
\newpage
\tableofcontents
\newpage
\section{Введение}
\tiny
дз1 = док Д6. особенное внимание к оформлению лаб и дом работ. разделитель десятичной части - запятая.
\normalsize
\subsection{Понятие обработки сигналов}
имеются аналоговые входные и выходные сигналы, и есть цифровая часть.
Аналоговый сигнал усиливается, фильтруется, АЦПируется, получили $x(\tau)$ буферизируется и поступает на сигнальный процессор, преобразуется в выход, задержанный на n тактов, поэлементно ЦАП, фильтруется и усиливается или ослабляется (рис. \hrf{pic:SignalProcessing}).
\begin{figure}[h]
  \centering
  \includegraphics[width=15cm]{00-SP.png}
  \caption{Обработка сигналов}
  \label{pic:SignalProcessing}
\end{figure}

То есть всегда накапливается n отсчётов и обработка происходит "пакетно", поскольку для одного значения не имеют смысла. Сигналы всегда задержаны на n тактов. Сигнальные процессоры бывают с фиксированной и плавающей запятой.

Узкое место фон-Неймановой архитектуры - один канал для доступа и управления и к командам и к данным. сигнальные процессоры разделяют каналы данных и команд (слайд19), гарвардская архитектура. Сигнальные процессоры позволяют отказаться от кэш-памяти совсем.

\subsection{Сигнальные процессоры}
СП сами по себе не используются, только в связке с другими процессорами. тактовые частоты обычно небольшие (поскольку данные поступают одновременно с командами, без задержек) из-за этого сильно развита ковейеризация. Прямой доступ к памяти доведён до максимума, нет времени заниматься вводом-выводом.

\begin{figure}[h]
  \centering
  \includegraphics[width=10cm]{00-SPC.png}
  \caption{Устройство обработки сигналов}
  \label{pic:inner-spd}
\end{figure}

Внутри (рис. \hrf{pic:inner-spd}) имеются средства обработки запросов пользователя, асики, два сигнальных ядра (внутри каждого есть память и у сигнальных ядер есть общая память). вся обработка осуществляется через кодеки. на примере на слайде указана ПЛИС для радиочастотного интерфейса.

\nomenclature[C]{ASIC}{Analog Specific Integrated Circuit (схема сопряжения)}
\nomenclature[C]{DSP}{Digital Signal Processors (процессор цифровой обработки сигналов)}
\nomenclature[C]{GPP}{General Purpose Processors (процессор общего назначения)}
\nomenclature[C]{FPGA}{Field Programmable Gate Array (программируемая логическая матрица)}
\nomenclature[C]{NoC}{Network on Chip (вычислительная сеть на кристалле)}
\nomenclature[C]{RF}{Radio Frequency}
\nomenclature[C]{Shared Bus}{общая шина}
\nomenclature[C]{SoC}{signal system on chips (обработка сигналов на кристалле)}
\nomenclature[C]{VLSI}{very large scale integration (сверхбольшая степень интеграции)}
\nomenclature[C]{CISC}{Complex Instruction Set Computer (проц. слож. набор команд)}
\nomenclature[C]{RISC}{Reduced Instruction Set Computer (проц. сокр. набор команд)}
\nomenclature[C]{ARM}{Advanced RISC Machine (усовершенствованный RISC-проц.)}
\nomenclature[C]{HDMI}{High-Definition Multimedia Interface, мультимедийный интерфейс}
\nomenclature[C]{MHL}{Mobile High-definition Link(1/2 HDM, TX - Transmit)}
\nomenclature[C]{NAND}{флэш-память типа NOT-AND}
\nomenclature[C]{NOR}{флэш-память типа NOT-OR}
\nomenclature[C]{SD/SDIO}{Secure Digital Input Output, интерфейс карт памяти SD}
\nomenclature[C]{FPU}{Float Pointer Unit, процессор с плавающей запятой}
\nomenclature[C]{GPU}{Graphics Processing Unit, графический процессор}
\nomenclature[C]{PLL}{Phase Locked Loop, фазовая автоподстройка}
\nomenclature[C]{RTC}{Real Time Clock, часы реального времени}
\nomenclature[C]{DAC}{Digital to Analog Converter, цифро-аналоговый преобразователь}
\nomenclature[C]{ADC}{Analog to Digital Converter, аналого-цифровой преобразователь}
\nomenclature[C]{PWM}{Pulse Width Modulation, широтно-импульсная модуляция}
\nomenclature[C]{(LP)DDR}{Low Power Double Data Rate, синхронная динам. память}
\nomenclature[C]{eMMC}{Embedded Multi Media Card, встроенный интерфейс карт}
\nomenclature[C]{SPI}{Serial Peripheral Interface, последов. периферийны интерфейс}
\nomenclature[C]{ROM}{Read Only Memory, постоянное запоминающее устройство}
\nomenclature[C]{SIMD}{Single Instruction Multiple Data, одна команда, много данных}
\nomenclature[C]{TRNG}{True Random Number Generator}
\nomenclature[C]{eFuse}{память динамического программирования микросхем}
\nomenclature[C]{HDR}{High Dynamic Range, увеличение динамического диапазона}
\nomenclature[C]{SSE(2)}{Streaming SIMD Extensions (2), потоковое SIMD-расширение}
\nomenclature[C]{H.264}{Advanced Video Coding, стандарт сжатия видео}
\nomenclature[C]{H.265}{High Efficiency Video Coding, стандарт сжатия видео}
\nomenclature[C]{VP9}{Video Processing 9, стандарт сжатия видео от Google}
\nomenclature[C]{JPEG}{Joint Photographic Experts Group, растровый формат}
\nomenclature[C]{USB}{Universal Serial Bus, универсальная последовательная шина}
\nomenclature[C]{PCIe}{Peripheral Component Interconnect Express, компьютерная шина}
\nomenclature[C]{SATA}{Serial Advanced Technology Attachment, посл. обмен данными}
\nomenclature[C]{MAC}{Media Access Control, управление доступом к среде}
\nomenclature[C]{PHY}{Physical layer, физический уровень}
\nomenclature[C]{IR}{Infrared interface, инфракрасный интерфейс}
\nomenclature[C]{TX/RX}{Transmitter/Receiver, передатчик-приемник}
\nomenclature[C]{GMII}{Gigabit Media-Independent Interface, гигабитный интерфейс}
\nomenclature[C]{RGMII}{Reduced GMII (1/2 GMII), улучшенный гигабитный интерфейс}
\nomenclature[C]{SGMII}{Serial GMII, последовательный гигабитный интерфейс}
\nomenclature[C]{Serial TP}{Serial Twisted Pair, витая пара}
\nomenclature[C]{UART}{Universal Asynchronous Receiver-Transmitter, УСПП}
\nomenclature[C]{GPIO}{general-purpose input/output, универсальный вход-выход}
\nomenclature[C]{I2C}{Inter-Integrated Circuit, приборный интерфейс}
\nomenclature[C]{LSADC}{Low Speed ADC, низкоскоростной многоканальный АЦП}
\nomenclature[C]{I2S}{Integrated Inter-chip Sound, звуковой интерфейс}
\nomenclature[C]{CEC}{Consumer Electronics Control, управление бытовой электроникой}

\section{Обработка сигналов}
ЦОС - это дискретная обработка сигналов. ЦОС - это обработка одномерных массивов, изображений - двумерных массивов. несмотря на то, что изображения приходят построчно

\textbf{Сигнал} – физический процесс, протекающий во времени и отражающий состояние некоторого объекта наблюдения

\textbf{Аналоговый сигнал} – непрерывная функция времени:
\[  \chi(t)\in[\chi_{min},\chi{max}]; t\in[t_{min},t_{max}]. \]

\textbf{Дискретный сигнал} – последовательность отсчетов аналогового сигнала в дискретные моменты времени с дискретными значениями: \[x(\tau)\in \overline{0, L - 1} (\tau = \overline{0, N - 1}).\]

слайд 4
(непрерывность - это математическое обобщение)
\begin{multicols}{2}
  \textbf{Квантование по времени}
  \[ \chi(t) \in [\chi_{min},\chi_{max}], t \in[t_{min}, t_{max}] \]
  \[ \Rightarrow \chi(\tau) \in [\chi_{min}, \chi_{max}](\tau = \overline{0, N-1}) \]
\columnbreak
\begin{tikzpicture}
  \begin{axis}[
    domain=0:360, axis x line*=middle, xtick=\empty, samples=15, width=9cm, height=4.5cm,
    xlabel=$t$, ylabel=$x(t)$
    ]
    \addplot [ycomb, mark=triangle*, thick, mark size=1] {sin(x) + 1};
    \addplot [densely dotted, samples=51] {sin(x) + 1};
  \end{axis}
\end{tikzpicture}
\end{multicols}

\begin{multicols}{2}
  \textbf{Квантование по уровню}
  \[ \chi(\tau) \in [\chi_{min}, \chi_{max}] \Rightarrow \chi(\tau) \in \overline{0, L - 1} \]
  \columnbreak
\begin{tikzpicture}
  \begin{axis}[
    domain=0:360, axis x line*=middle, xtick=\empty, samples=30, width=9cm, height=4.5cm,
    xlabel=$t$, ylabel=$x(t)$
    ]
    \addplot [const plot mark mid, very thick, gray] {sin(x) + 1};
    \addplot [densely dotted, samples=51] {sin(x) + 1};
  \end{axis}
\end{tikzpicture}
\end{multicols}

\begin{multicols}{2}
  \textbf{Дискретный сигнал}
  \[ \chi(\tau) \in \overline{0, L - 1} (\tau = \overline{0, N-1}) \]
  \[ t = t_{min} + \tau T, T = \frac{t_{max} - t_{min}}{N} \]
  \[\chi = \chi_{min} + x D, D = \frac{\chi_{max} - \chi_{min}}{L}\]
  \columnbreak
\begin{tikzpicture}
  \begin{axis}[
    domain=0:360, axis x line*=middle, xtick=\empty, samples=15, width=9cm, height=4.5cm,
    xlabel=$t$, ylabel=$x(t)$
    ]
    \addplot [const plot mark mid, very thick, gray] {sin(x) + 1};
    \addplot [ycomb, mark=triangle*, thick, mark size=1] {sin(x) + 1};
    \addplot [densely dotted, samples=51] {sin(x) + 1};
  \end{axis}
\end{tikzpicture}
\end{multicols}

\subsection{Что мы, в принципе, можем сделать с сигналом?}
\label{subsect:methods}
\begin{itemize}
\item \textbf{Передискретизация} – изменение частоты дискретизации (многоскоростная обработка).
  \[ x(0), x(1),... , x(N - 1) \Rightarrow y(0), y(1),... , y(M - 1) \]
Представлена процессами \textbf{децимации} и \textbf{интерполяции}. При интерполяции - дополняем отсчёты промежуточными (увеличение частоты дискретизации) и пытаемся аппроксимировать. При децимации наоборот, уменьшение частоты дискретизации.
\item \textbf{Преобразование} – функциональное преобразование сигнала по одному отсчету.
\begin{itemize}
\item Нелинейное $ y(\tau) = f(x(\tau)) (\tau = \overline{0, N - 1})$;
\item Модуляция $ y(\tau) = f(x(\tau), m(\tau)) (\tau = \overline{0, N - 1})$;
\item Манипуляция $ y(\tau) = f(x(\tau), b(\tau)) (\tau = \overline{0, N - 1})$.
\end{itemize}
Выполняется независимо от других отсчётов. например нелинейное преобразование - это ограничение звукового сигнала. В отличие от простого ограничения происходит плавное изменение максимума. Иногда преобразование происходит с учётом какого-то другого сигнала - это манипуляция или модуляция. Как примеры: нелинейное - просто обрезать крайние значения синусоиды до уровня. Модуляция, манипуляция - АМ, ЧМ, ФМ.
\item \textbf{Корреляция} – проверка степени линейной зависимость сигналов.
  \begin{equation*}
    \begin{split}
    r(\tau) = \frac{1}{N}\sum_{k=0}^{K - \tau - 1}x(\tau + k) \times y(k)\\
    (\tau = \overline{0, K-1})\\
    K = N + M - 1\\
    x(i \pm N) = x(i) (i = \overline{0, N - 1})\\
    y(j \pm M) = y(j) (j = \overline{0, M - 1})
    \end{split}
  \end{equation*}
  
  \begin{figure}[H]
    \centering
    \begin{subfigure}[b]{0.6\textwidth}
      \centering
      \includegraphics[width=\textwidth]{01-correl1.png}
    \end{subfigure}
    \hfill
    \begin{subfigure}[b]{0.3\textwidth}
      \centering
      \includegraphics[width=\textwidth]{01-correl2.png}
    \end{subfigure}
  \end{figure}

Используются при обработке сигналов связи. Сравниваем входящий сигнал который имеет N отсчётов с другим сигналом с M отсчётов и определяем меру подобия. Считается мерой линейной связи сигналов. Вычисляем похожесть с учётом сдвигов сигналов относительно друг друга. Фактически получается сумма произведений сигналов. Когда смещение сигналов нулевое - корелляционная функция максимальная.
\item \textbf{Фильтрация (не)рекурсивная} – нелинейная (линейная) обработка сигнала.
  \[ y(\tau) = \sum_{i=0}^{H-1} h(i) \times x(\tau - i) (\tau = \overline{0, N - 1}) \]

  Функция, которую можно представить как линейную обработку сигналов (также сумма произведений). Например, усреднение сигнала. Для работы надо знать несколько предыдущих значений (на глубину количества отсчётов импульсной характеристики). Важно не забыть про значения задержки. Коэффициенты можно посчитать в матлабе. Это фильтр с конечной импульсной характеристикой.
  \begin{figure}[H]
    \centering
    \begin{subfigure}[b]{0.2\textwidth}
      \includegraphics[width=\textwidth]{01-fic1.png}
    \end{subfigure} \hfill
    \begin{subfigure}[b]{0.5\textwidth}
      \includegraphics[width=\textwidth]{01-fic2.png}
    \end{subfigure}

    \begin{subfigure}[b]{0.2\textwidth}
      \includegraphics[width=\textwidth]{01-fic3.png}
    \end{subfigure} \hfill
    \begin{subfigure}[b]{0.7\textwidth}
      \includegraphics[width=\textwidth]{01-fic4.png}
    \end{subfigure}
  \end{figure}


  \textbf{Рекурсивный фильтр} - есть обратные связи. Бесконечная импульсная характеристика.
\[y(\tau) = \sum_{i=0}^{H-1} h(i) \times x(\tau - i) - \sum_{j=1}^G g(j) \times y(\tau - j) (\tau = \overline{0, N - 1})\]
Повторяет нерекурсивный фильтр и добавляется ещё G элементов задержки. Индекс значений начинается с нуля, а выходных отсчётов с единицы. Характерны возможностью возбуждения (как микрофон возле динамика), неверно подобранные коэффициенты могут приводить к неустойчивости фильтра. На рис. фильтр устойчивый, потому что площадь над Х больше площади под Х. Все нерекурсивные фильтры устойчивы.
\begin{figure}[H]
  \centering
  \includegraphics[width=17cm]{01-iic1.png}
\end{figure}

\item \textbf{Фильтрация адаптивная} – фильтрация с изменением характеристик фильтра.
  \begin{tikzpicture}[
      x=0.75pt, y=0.75pt,
      yscale=-1, xscale=1,
      outline/.style={draw=#1, thick},
      outline/.default=black,
      ]
      \tkzblk{outline}{75,100}{АЦП}
      \tkzblk{outline}{175,100}{АУ}
      \tkzblk{outline}{175,50}{П}
      \tkzblk{outline}{175,150}{ГС}
      \tkzblk{outline}{275,100}{ЦАП}
      \tkzblk{outline}{375,100}{СФ}

      \draw [dashed] (150,25) rectangle (200, 125);
      \draw [-|>] (0, 100) -- (48,100) node[above left] {$x(t)$};
      \draw [-|>] (102, 100) -- (155,100) node[above left] {$x(n)$};
      \draw [-|>] (195, 100) -- (248,100) node[above left] {$y(n)$};
      \draw [-|>] (302, 100) -- (355,100) node[above left] {$y(t)$};
      \draw [-|>] (395, 100) -- (455,100) node[above left] {$\tilde{y}(t)$};
      \draw [-|>] (175, 135) -- (75,115);
      \draw [-|>] (175, 135) -- (175,115);
      \draw [-|>] (175, 135) -- (275,115);
      \draw [-] (190, 50) -- (275,40) node[right]{Процессор};
      \draw [<|-] (165, 65) -- (165,85);
      \draw [-|>] (185, 65) -- (185,85);
  \end{tikzpicture}

  \begin{figure}[H]
    \includegraphics[width=17cm]{01-adapt.png}
  \end{figure}
    
  Цифровая фильтрация: имеется АЦП, генератор тактов, и арифметическое устройство, накапливающий сумматор, ЦАП. Адаптивная фильтрация - это фильтр при которой изменяются коэффициенты фильтра. Обычно это нерекурсивная фильтрация, но можно сделать и рекурсивный фильтр. При адаптивной фильтрации имеется дополнительный вход с шумами сопровождающими полезный сигнал. Шум попадает в блок адаптации чтобы изменять коэффициенты, это делается для того, чтобы минимизировать ошибку.
  \begin{equation*}
    \begin{split}
      y(\tau) = \sum_{i=0}^{H-1} h(i) \times x(\tau - i)\\
      e(\tau) = d(\tau) - y(\tau)\\
      \tilde{h}(i) = h(i) + \mu \times e(\tau) \times x(\tau - i)\\
      i = \overline{0, H-1}; \tau = \overline{0, N - 1}; \mu \in (0,1]
    \end{split}
  \end{equation*}
\item \textbf{Спектральная обработка(13-16)} – обработка сигнала в спектральной области.

  \includegraphics[width=15cm]{01-spectral1.png}

  самое сложное - это спектральное преобразование Фурье. Сложное не только потому что раскладываем не только во времени, но и в амплитуде. Один комплект отсчётов для амплитуды, а второй для фазы. Получив коэффициенты можем менять сам сигнал. Для обработки изображений используется косинусное преобразование (для сжатия изображений). В дискретном виде спектральное преобразование выглядит следующим образом:
\begin{enumerate}
\item прямое коэффициенты умножаем на матрицу получаем вектор для преобразования.
  \[c(i) = \sum_{\tau=0}^{N-1} r_i(\tau) \times x(\tau); C = R \times X\]
\item обратное коэффициенты умножаем на матрицу обратного преобразования - получаем входной сигнал.
  \[x(\tau) = \sum_{i=0}^{N-1} s_\tau(i) \times c(i); X = S \times C\]
\item если взять матрицы из первых двух пунктов и умножить - получим единичную матрицу.
  \[ \delta_{i\tau} = \sum_{j=0}^{N-1} r_i(j) \times s_\tau(j); R \times S = I\]
\end{enumerate}

\includegraphics[width=15cm]{01-spectral3.png}

сложность в том что мы ловим операции, которые можно исключить. На практике используются только быстрые преобразования фурье - это не просто умножение матриц, а некоторые умножения исключаются. Также существуют вариации спектрального преобразования

\includegraphics[width=15cm]{01-spectral2.png}

В этой обработке предполагается восстановление сигнала - после ЦАП ставим фильтр низких частот.

\includegraphics[width=15cm]{01-spectral4.png}

Частота среза фильтра считается по теореме Котельникова.

\includegraphics[width=15cm]{01-spectral5.png}

\end{itemize}

\section{Представление целых чисел}
Используются числа с фиксированной запятой из-за скорости таких вычислений.
Числа бывают:
\begin{itemize}
\item Натуральные числа: N8, N16, N32, N64. Число = разрядность, N = натуральное
\item Целые числа: Z8, Z16, Z32, Z64. (\textit{Z, видимо, znakovoe, прим. Овчинников})
\item Числа с фиксированной запятой: Q4.12, Q1.15, Q1.31. Числа = разрядности до и после запятой, соотвествтенно\footnote{Wikipedia: The Q notation, as defined by Texas Instruments, consists of the letter Q followed by a pair of numbers m.n, where m is the number of bits used for the integer part of the value, and n is the number of fraction bits.}
\item Числа с плавающей запятой: F32, F64, F80. F = floating point.
\item Рациональные числа $\frac{\text{числитель}}{\text{знаменатель}}$: R8, R16, R32, R64.
\item Логарифмические форматы (логарифм значения и знак).
\item Символьные форматы.
\end{itemize}
\subsection{Целые и натуральные числа}
Натуральные числа представлены двумя типами: знаковым и беззнаковым. Знаковое представлено в дополнительном коде.
\begin{frm}
  \textit{Фрагмент (Овчинников, неопубликованное, 2019)}: Преобразование из системы счисления с бОльшим основанием в систему счисления с меньшим основанием производится последовательным делением исходного числа на основание системы счисления и записи остатков такого деления в младшие разряды. Например:
  \[
    \frac{116}{2} = \frac{58 (0)}{2} = \frac{29 (0)}{2} = \frac{14 (1)}{2} = \frac{7 (0)}{2} = \frac{3 (1)}{2} = \frac{1 (1)}{2} = 1 < 2
  \]
  В этом примере полученные остатки от деления записаны в скобках. Обратное преобразование - это последовательное умножение разрядов числа на величину каждого разряда с их аккумулированием к общему результату:
  \begin{equation*}
    \begin{gathered}
      1110100 = 0 \cdot 2^0 + 0 \cdot 2^1 + 1 \cdot 2^2 + 0 \cdot 2^3 + 1 \cdot 2^4 + 1 \cdot 2^5 + 1 \cdot 2^6 = \\
      0 \cdot 1 + 0 \cdot 2 + 1 \cdot 4 + 0 \cdot 8 + 1 \cdot 16 + 1 \cdot 32 + 1 \cdot 64 = \\
      4 + 16 + 32 + 64 = 116
    \end{gathered}
  \end{equation*}
\end{frm}
\textbf{Формат N:} при последовательном сложении значений разрядов, умноженных на двойку в степени позиции в приведённой ниже таблице получим число 33121.

  \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|} 
    $x_{15}$ & $x_{14}$ & $x_{13}$ & $x_{12}$ & $x_{11}$ & $x_{10}$ & $x_{9}$ & $x_{8}$ & $x_{7}$ & $x_{6}$ & $x_{5}$ & $x_{4}$ & $x_{3}$ & $x_{2}$ & $x_{1}$ & $x_{0}$ \\ [0.5ex] 
    $2^{15}$ & $2^{14}$ & $2^{13}$ & $2^{12}$ & $2^{11}$ & $2^{10}$ & $2^{9}$ & $2^{8}$ & $2^{7}$ & $2^{6}$ & $2^{5}$ & $2^{4}$ & $2^{3}$ & $2^{2}$ & $2^{1}$ & $2^{0}$ \\ [0.5ex] 
    \hline
    1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 1 & 0 & 0 & 0 & 0 & 1 \\
    \hline
  \end{tabular}
\[ X = \sum_{i=0}^{15} x_i \cdot 2^i \]
\textbf{Формат Z:} Знаковым является самый старший разряд, соответственно, даёт наибольшее промежуточное значение с нужным знаком, чтобы никакие дальнейшие вычисления не смогли сменить знак. Поэтому аналогичное двоичное представление числа при вычислениях со знаком даст результат -32415. 
\[ X = -s \times 2^{15} + \sum_{i=0}^{14} x_i \cdot 2_i \]

Соответственно, при любой разрядности (L03-04, L03-05), с точностью $\varepsilon = 1$ (поскольку числа - целые), у беззнаковых чисел все биты занимаются хранимым значением, а у знаковых старший бит отводится под знак, отсюда диапазоны возможных принимаемых значений\footnote{квадратные скобки означают нестрогое неравенство, включение во множество, круглые скобки означают строгое неравенство, исключение из множества}:
\begin{itemize}
\item [N16] $[0,65535]$
\item [Z16] $[-32768,32767]$
\item [N32] $[0,4929967295]$
\item [Z32] $[-2147483648,2147483647]$
\end{itemize}
Шестнадцатиричное представление аналогично двоичному, просто двоичные разряды разделены на тетрады и обозначаются цифрами 0-F.

\subsection{Внутренний формат}
\textbf{N40 [0, 1099511627775].} Это обычные 32-разрядные целые числа и 8 защитных разрядов (защищают от переполнения).
\begin{frm}
Для смены знака числа нужно инвертировать разряды и добавить единицу. АЛУ работает только со сложением и все остальные операции работают через него.
\end{frm}
Для беззнаковых чисел есть флаги переноса и заёма (CF,SF).

\begin{tikzpicture}
\draw (0,0)coordinate (O)--++(30:1)coordinate (A)--++(90:2)coordinate (B)--++(150:1)coordinate (C)--cycle;
\draw [->]($(A)!0.5!(B)$)--++(0:1)node[right]{$Z(N40)$};
\draw [->]($(O)!0.5!(A)$)--++(-90:1)--++(0:2)node[right]{$CF$};
\draw [->]($(O)!0.25!(A)$)--++(-90:1.5)--++(0:2.25)node[right]{$SF$};
\draw [->]($(O)!0.75!(A)$)--++(-90:0.5)--++(0:1.75)node[right]{$ZF$};
\draw [<-]($(B)!0.5!(C)$)--++(90:0.5)--++(180:1.75)node[left]{$C_0$};
\draw [<-]($(C)!0.33!(O)$)--++(180:0.5) node[left]{$X(N40)$};
\draw [<-]($(C)!0.67!(O)$)--++(180:0.5) node[left]{$Y(N40)$};
\end{tikzpicture}

\[ X_{N40} = \sum_{i=0}^{39}x_i \times 2^i \]
\[ CF = c_{40}, SF = z_{39}, ZF = \&_{i=0} \overline{z}_i \]
\[ c_0 = 0, c_i + x_i + y_i = z_i + 2 \cdot c_{i+1} \]
\[ b_0 = 0, -b_i + x_i - y_i = z_i - 2 \cdot b_{i+1} \]
\[ X_{N40} + Y_{N40} = \sum_{i=0}^{39} x_i \cdot 2^i + \sum_{i=0}^{39} y_i \cdot 2^i = c_{40} \cdot 2^{40} + \sum_{i=0}^{39} z_i \cdot 2^i | CF=0 \]
\[ X_{N40} - Y_{N40} = \sum_{i=0}^{39} x_i \cdot 2^i + \sum_{i=0}^{39} y_i \cdot 2^i + 1 | CF = 1 \]

\begin{multicols}{3}
  $z = x + y$
  
  \begin{tabular}{|ccc|cc|} 
    \hline
    $c_i$ & $x_i$ & $y_i$ & $z_i$ & $c_{i+1}$ \\
    \hline
    0 & 0 & 0 & 0 & 0 \\
    0 & 0 & 1 & 1 & 0 \\
    0 & 1 & 0 & 1 & 0 \\
    0 & 1 & 1 & 0 & 1 \\
    1 & 0 & 0 & 1 & 0 \\
    1 & 0 & 1 & 0 & 1 \\
    1 & 1 & 0 & 0 & 1 \\
    1 & 1 & 1 & 1 & 1 \\
    \hline
  \end{tabular}

  \columnbreak

  $z = x - y$
  
  \begin{tabular}{|ccc|cc|} 
    \hline
    $b_i$ & $x_i$ & $y_i$ & $z_i$ & $b_{i+1}$ \\
    \hline
    0 & 0 & 0 & 0 & 0 \\
    0 & 0 & 1 & 1 & 1 \\
    0 & 1 & 0 & 1 & 0 \\
    0 & 1 & 1 & 0 & 0 \\
    1 & 0 & 0 & 1 & 1 \\
    1 & 0 & 1 & 0 & 1 \\
    1 & 1 & 0 & 0 & 0 \\
    1 & 1 & 1 & 1 & 1 \\
    \hline
  \end{tabular}

  \columnbreak

  $z = x + \overline{y} + 1; c_i = \overline{b_i}$
  
  \begin{tabular}{|ccc|cc|} 
    \hline
    $\overline{b}_i$ & $x_i$ & $\overline{y}_i$ & $z_i$ & $\overline{b}_{i+1}$ \\
    \hline
    0 & 0 & 0 & 0 & 0 \\
    0 & 0 & 1 & 1 & 0 \\
    0 & 1 & 0 & 1 & 0 \\
    0 & 1 & 1 & 0 & 1 \\
    1 & 0 & 0 & 1 & 0 \\
    1 & 0 & 1 & 0 & 1 \\
    1 & 1 & 0 & 0 & 1 \\
    1 & 1 & 1 & 1 & 1 \\
    \hline
  \end{tabular}
  
\end{multicols}

\textbf{Z40 [-549755813888, 549755813887]} для целых чисел есть флаг знака и знак переполнения (SF, OF).

\begin{tikzpicture}
\draw (0,0)coordinate (O)--++(30:1)coordinate (A)--++(90:2)coordinate (B)--++(150:1)coordinate (C)--cycle;
\draw [->]($(A)!0.5!(B)$)--++(0:1)node[right]{$Z(N40)$};
\draw [->]($(O)!0.5!(A)$)--++(-90:1)--++(0:2)node[right]{$OF$};
\draw [->]($(O)!0.25!(A)$)--++(-90:1.5)--++(0:2.25)node[right]{$SF$};
\draw [->]($(O)!0.75!(A)$)--++(-90:0.5)--++(0:1.75)node[right]{$ZF$};
\draw [<-]($(B)!0.5!(C)$)--++(90:0.5)--++(180:1.75)node[left]{$C_0$};
\draw [<-]($(C)!0.33!(O)$)--++(180:0.5) node[left]{$X(N40)$};
\draw [<-]($(C)!0.67!(O)$)--++(180:0.5) node[left]{$Y(N40)$};
\end{tikzpicture}

Компилятор не может выполнять операции не в модулярной арифметике. Это позволяет генерировать исключения при переполнении разрядной сетки.
\begin{equation}
  X_{Z40} = -s_x \cdot 2^{39} + \sum_{i=0}^{38} x_i \cdot 2^i
  \label{eq:xz-40}
\end{equation}

\[ Y_{Z40} = -s_y \cdot 2^{39} + \sum_{i=0}^{38} y_i \cdot 2^i \]
  \begin{equation*}
    \begin{gathered}
      X_{Z40} + Y_{Z40} =\\
      = -s_x \cdot 2^{39} + \sum_{i=0}^{38} x_i \cdot 2^i - s_y \cdot 2^{39} + \sum_{i=0}^{38} y_i \cdot 2^i =\\
      = -(s_x + s_y + c_{39}) \cdot 2^{39} + \sum_{i=0}^{38} z_i \cdot 2^i =\\
      = -s_z \cdot 2^{39} + \sum_{i=0}^{38} z_i \cdot 2^i | OF = 0
    \end{gathered}
  \end{equation*}

    \begin{tabular}{|ccc|cc|c|} 
    \hline
    $s_x$ & $s_y$ & $c_{39}$ & $c_{40}$ & $s_z$ & OF \\
    \hline
    0 & 0 & 0 & 0 & 0 & 0 \\
    \cellcolor{red!25}{0} & \cellcolor{red!25}{0} & 1 & 0 & \cellcolor{red!25}{1} & 1 \\
    0 & 1 & 0 & 0 & 1 & 0 \\
    0 & 1 & 1 & 1 & 0 & 0 \\
    1 & 0 & 0 & 0 & 1 & 0 \\
    1 & 0 & 1 & 1 & 0 & 0 \\
    \cellcolor{red!25}{1} & \cellcolor{red!25}{1} & 0 & 1 & \cellcolor{red!25}{0} & 1 \\
    1 & 1 & 1 & 1 & 1 & 0 \\
    \hline
    \end{tabular}
    
    $OF = c_{40} \oplus c_{39}$

\subsection{АЛУ}
АЛУ обирает 40 одноразрядных сумматоров.

\begin{multicols}{2}
\begin{tikzpicture}[circuit logic IEC]
\matrix[column sep=10mm]
  {
    \node (ci) {$c_i$}; &                          & \node [or gate] (a1) {};  & \\
                        & \node [or gate](i0) {};  &                           & \\
    \node (xi) {$x_i$}; &                          & \node [and gate] (a2) {}; & \\
                        & \node [and gate](i1) {}; &                           & \node [or gate] (o) {};\\
    \node (yi) {$y_i$}; &                          &                           & \\
  };

  \draw (ci.east) -- ++(right:2mm) |- (a1.input 1);
  \draw (xi.east) -- ++(right:4mm) |- (i0.input 1);
  \draw (xi.east) -- ++(right:4mm) |- (i1.input 1);
  \draw (yi.east) -- ++(right:6mm) |- (i0.input 2);
  \draw (yi.east) -- ++(right:6mm) |- (i1.input 2);

  \draw (ci.east) -- ++(right:2mm) |- (a2.input 1);
  \draw (i0.output) -- ++(right:7mm) |- (a1.input 2);
  \draw (i0.output) -- ++(right:7mm) |- (a2.input 2);

  \draw (a2.output) -- ++(right:5mm) |- (o.input 1);
  \draw (i1.output) -- ++(right:5mm) |- (o.input 2);

  \draw (a1.output) -- ++(right:23mm) node [right] {$Z_i$};
  \draw (o.output) -- ++(right:3mm) node [right] {$C_{i+1}$};
\end{tikzpicture}

  \columnbreak

  \includegraphics[width=9cm]{01-alu1.png}
\end{multicols}

Если на мультиплексоры подавать разные значения К то будут выполняться разные операции - сложение или вычитание.
\[CF = c_{40}, SF = z_{39}, OF = c_{40} \oplus c_{39}, ZF = \&_{i=0}^{39}\overline{z}_i \]
CF=carry, SF=sign, OF=overflow, ZF=zero.

\begin{multicols}{2}
  \begin{tabular}{|ccc|cc|} 
    \hline
    $c_i$ & $x_i$ & $y_i$ & $z_i$ & $с_{i+1}$ \\
    \hline
    0 & 0 & 0 & 0 & 0 \\
    0 & 0 & 1 & 1 & 0 \\
    0 & 1 & 0 & 1 & 0 \\
    0 & 1 & 1 & 0 & 1 \\
    1 & 0 & 0 & 1 & 0 \\
    1 & 0 & 1 & 0 & 1 \\
    1 & 1 & 0 & 0 & 1 \\
    1 & 1 & 1 & 1 & 1 \\
    \hline
  \end{tabular}

  \columnbreak

  \begin{tabular}{|c|c|}
    \hline
    $K_x$ & A \\
    \hline
    0 & X \\
    1 & $\overline{X}$ \\
    2 & -1 \\
    3 & 0 \\
    \hline
  \end{tabular}
\end{multicols}

\subsection{Проблемы двоичной арифметики}
Флаги результата операции:
\begin{itemize}
\item ZF – Zero (флаг нуля) – равенство всех разрядов результата нулю;
\item CF – Carry (флаг переноса) – наличие переноса за пределы разрядной сетки;
\item OF – Overflow (флаг переполнения) – не равенство переноса из знакового разряда результата переносу в знаковый разряд;
\item SF – Sign (флаг знака) – наличие единицы в знаковом разряде результата.
\end{itemize}

\setlength\tabcolsep{2pt}
\begin{tabular}{ccccc}
  \begin{arithmetic}
          0010~2~2 &\\
   +      0010~2~2 &\\
          0100~4~4 &\\
  \end{arithmetic}
&
  \begin{arithmetic}
          0110~~~6~6 &\\
   +      0010~~~2~2 &\\
          1000~-8~8 &\\
  \end{arithmetic}
&
  \begin{arithmetic}
          1110~-2~14 &\\
   +      1010~-6~10 &\\
          1000~~-8~8 &\\
  \end{arithmetic}
&
  \begin{arithmetic}
          0110~~~6~~6 &\\
   +      1110~-2~14 &\\
          0100~~~4~~4 &\\
  \end{arithmetic}
&
  \begin{arithmetic}
          1010~-6~10 &\\
   +      1100~-4~12 &\\
          0110~~~6~~6 &\\
  \end{arithmetic}
  \\
CF=0, OF=0&
CF=0, OF=1&
CF=1, OF=0&
CF=1, OF=0&
CF=1, OF=1\\
\end{tabular}
\setlength\tabcolsep{6pt}

для контроля правильности вычислений нужно дописать встроенную функцию. если включается режим контроля переполнения в компиляторе - программа работает медленнее и/или занимает больше места.
\begin{lstlisting}[language=C,style=CCodeStyle]
  static inline int CF() {
    int c = 1; // *SP(1)
    asm(
    “BCC L1, CARRY
     MOV #0, *SP(1)
     L1: NOP“);
    return c;
  }
//
unsigned int x, y, z;
int t;
x = 0xFDE3, y = 0x71A4;
t = -x; if (CF() == 0) error();
z = x + y; if (CF() == 1) error();
z = x - y; if (CF() == 0) error();

int x, y, z;
x = 0xFDE3, y = 0x71A4;
z = -x; if(OF() == 0) error();
z = x + y; if (ОF() == 1) error();
z = x - y; if (ОF() == 0) error();
\end{lstlisting}

\textbf{Мнемоники для работы с числами в МК}

\begin{tabular}{|c|c|c|}
  \hline
  Код J* & Название                                               & Условие \\
  C      & Carry (перенос)                                        & $C = 1$ \\
  NC     & No carry (не перенос)                                  & $C = 0$ \\
  S      & Sign (знак)                                            & $S = 1$ \\
  NS     & No sign (не знак)                                      & $S = 0$ \\
  E, Z   & Equal (равно), zero (нуль)                             & $Z = 1$ \\
  NE, NZ & No equal (не равно), no zero (не нуль)                 & $Z = 0$ \\
  O      & Overflow (переполнение)                                & $V = 1$ \\
  NO     & No overflow (не переполнение)                          & $V = 0$ \\
  \rowcolor{yellow}
  L, NGE & Less (меньше), no great or equal (не больше или равно) & $S \^{} V = 1$ \\
  \rowcolor{yellow}
  GE, NL & Great or equal (больше или равно), no less (не меньше) & $S \^{} V = 0$ \\
  \rowcolor{yellow}
  LE, NG & Less or equal (меньше или равно)                       & $(S \^{} V) | Z = 1$ \\
  \rowcolor{yellow}
  G, NL  & Great (больше), no less (не меньше)                    & $(S \^{} V) | Z = 0$ \\
  \rowcolor{green}
  B, NAE & Below (ниже), no above or equal (не выше или равно)    & $C = 1$ \\
  \rowcolor{green}
  AE, NB & Above or equal (выше или равно), no below (не ниже)    & $C = 0$ \\
  \rowcolor{green}
  BE, NA & Below or equal (ниже или равно), no above (не выше)    & $C | Z = 1$ \\
  \rowcolor{green}
  A, NBE & Above (выше), no below or equal (не ниже или равно)    & $C | Z = 1$ \\
  \hline
\end{tabular}

где \lh{yellow}{знаковый формат чисел}, и \lh{green}{формат чисел без знака}.

\subsection{Преобразование целых чисел}
Если расширяем c 32-разрядного числа - расширяем знак, если сужаем до 32-разрядного - можем потерять данные, если знак в целевом (32м) разряде или старше - не совпал со знаковым разрядом источника (40). Представление 40-разрядного числа (\hrf{eq:xz-40}).
\[  X_{Z32} = -s_x \cdot 2^{31} + \sum_{i=0}^{30} x_i \cdot 2^i \]
В данном случае сумма - это геометрическая прогрессия
\[ \sum_{i=0}^{n-1} aq^i = a\frac{q^n - 1}{q - 1} \]
Поэтому, преобразование в меньшую разрядность можно представить следующим образом:
\[ 2^{39} - \sum_{i=31}^{38} = 2^{39} - 2^{31} \frac{2^8 - 1}{2 - 1} = 2^{31} \]
А преобразование в б\'{о}льшую разрядность так:
\begin{equation*}
  \begin{gathered}
    X_{Z32} = -s_x \cdot 2^{31} + \sum_{i=0}^{30} x_i \cdot 2^i =\\
    = -s\big(2^{39} - \sum_{i=31}^{38}2^i\big) + \sum_{i=0}^{30}x_i \cdot 2^i =\\
    = -s\cdot 2^{39} + \sum_{i=0}^{38}x_i\cdot 2^i
    \Bigg|\substack{x_{38} = s\\x_{37} = s\\...\\x_{31} = s}
  \end{gathered}
\end{equation*}

\subsection{Умножение натуральных чисел}
Для умножения сумматор не годится. Результат умножения получается в два раза длиннее (по разрядности) исходных. Мы не можем представить умножение в общем виде, но можем посчитать максимальную разрядность результата. Такое вычисление можно представить в следующем виде:
\begin{equation*}
  \begin{gathered}
    X_{N16} = \sum_{i=0}^{15} x_i \cdot 2^i, Y_{N16} = \sum_{i=0}^{15} y_i \cdot 2^i, Z = X_{N16} \cdot Y_{N16}.\\
    Z = \Big(\sum_{i=0}^{15}x_i \cdot 2^i \Big) \Big(\sum_{i=0}^{15}y_i \cdot 2^i \Big)\\
    Z_{max} = \sum_{i=0}^{15}2^i \cdot \sum_{i=0}^{15}2^i = (2^{16} - 1)(2^{16}-1) = 2^{32} - 2^{17} + 1\\
    Z_{min} = 0\\
    Z_{N32} = \sum_{i=0}^{31}z_i \cdot 2^i
  \end{gathered}
\end{equation*}

В представлении операции на языке С можно записать следующим образом\footnotemark{}:
\begin{lstlisting}[language=C,style=CCodeStyle]
  unsigned int x, y;
  unsigned long z;
  x = 0xFDE3, y = 0x71A4;
  z = (long)x * y;
\end{lstlisting}


\subsection{Умножение целых чисел}
Для умножения знаковых нужно на один разряд меньше, чем в два раза больше от исходных, надо расширять знак на 32й разряд.
\begin{equation*}
  \begin{gathered}
    X_{Z16} = -s_x \cdot 2^{15} + \sum_{i=0}^{14} x_i \cdot 2^i,  Y_{Z16} = -s_y \cdot 2^{15} + \sum_{i=0}^{14} y_i \cdot 2^i, Z = X_{N16} \cdot Y_{N16}.\\
    Z = \Big(-s_x \cdot 2^{15} + \sum_{i=0}^{14}x_i \cdot 2^i \Big) \Big(-s_x \cdot 2^{15} + \sum_{i=0}^{14}y_i \cdot 2^i \Big)\\
    Z_{max} = (-2^{15})(-2^{15}) = 2^{30}\\
    Z_{min} = -2^{15}\sum_{i=0}^{14} 2^i = -2^{15} \cdot (2^{15} - 1) = -2^{30} + 2^{15}\\
    Z_{Z32} = -s_z \cdot 2^{31} + \sum_{i=0}^{30}z_i \cdot 2^i, s_z = z_{30} \text{(расширение знака)}
  \end{gathered}
\end{equation*}

В представлении операции на языке С можно записать следующим образом\footnotemark[\value{footnote}]:
\begin{lstlisting}[language=C,style=CCodeStyle]
  int x, y;
  long z;
  x = 0xFDE3, y = 0x71A4;
  z = (long)x * y;
\end{lstlisting}
\footnotetext{прим. Овчинников - В языке С тип long имеет такую же разрядность, как int (в том числе согласно Википедии), поэтому такое преобразование не имеет смысла. Вероятнее всего оно применимо для конкретной весии компилятора (для данного в курсе МК) но точно не в «общем случае»}
\subsection{Аппаратный умножитель}
(L03-14) Аппаратный умножитель работает как умножение в столбик
\[S_i = c_{i-1} \oplus a_i \oplus b_i\]

\textbf{из книги Харрис и Харрис} \cite[стр. 252-253]{digital-design} \textit{(изображения на слайде L03-14 приведены оттуда)}
Multiplication of unsigned binary numbers is similar to decimal multiplication but involves only 1’s and 0’s. Figure \hrf{pic:h-h-mult} compares multiplication in decimal and binary. In both cases, partial products are formed by multiplying a single digit of the multiplier with the entire multiplicand. The shifted partial products are summed to form the result.
\begin{figure}[h]
  \centering
  \begin{subfigure}[b]{0.4\textwidth}
    \centering
    \begin{equation*}
      \begin{arithmetic}
           230 & multiplicand\\
    \times  42 & multiplier\\
           460 & partial\\
  +       920~ & products\\
          9660 & result
      \end{arithmetic}
    \end{equation*}
    \caption{decimal $230 \times 42 = 9660$}
    \label{pic:h-h-m-d}
  \end{subfigure}
  \hfill
  \begin{subfigure}[b]{0.4\textwidth}
    \centering
    \begin{equation*}
      \begin{arithmetic}
           0101 & multiplicand\\
    \times 0111 & multiplier\\
           0101 & partial\\
           0101 & products\\
          0101~ &\\
         0101~~ &\\
  +     0000~~~ &\\
        0100011 & result
      \end{arithmetic}
    \end{equation*}
    \caption{binary $5 \times 7 = 35$}
    \label{pic:h-h-m-b}
  \end{subfigure}
  \caption{Multiplication}
  \label{pic:h-h-mult}
\end{figure}

In general, an N×N multiplier multiplies two N-bit numbers and produces a 2N-bit result. The partial products in binary multiplication are either the multiplicand or all 0’s. Multiplication of 1-bit binary numbers is equivalent to the AND operation, so AND gates are used to form the partial products.
Figure \hrf{pic:h-h-44-mult} shows the symbol, function, and implementation of a $4 \times 4$ multiplier. The multiplier receives the multiplicand and multiplier, A and B, and produces the product P. Figure \hrf{pic:h-h-44-func} shows how partial products are formed. Each partial product is a single multiplier bit ($B_3, B_2, B_1, or B_0$) \code{AND} the multiplicand bits ($A_3, A_2, A_1, A_0$). With N-bit operands, there are N partial products and N − 1 stages of 1-bit adders. For example, for a $4 \times 4$ multiplier, the partial product of the first row is $B_0$ \textbf{AND} ($A_3, A_2, A_1, A_0$). This partial product is added to the shifted second partial product, $B_1$ \code{AND} ($A_3, A_2, A_1, A_0$). Subsequent rows of \code{AND} gates and adders form and add the remaining partial products.

\begin{figure}[H]
  \centering
  \begin{subfigure}[b]{0.1\textwidth}
    \centering
    \begin{tikzpicture}[
      x=0.75pt, y=0.75pt,
      yscale=-2, xscale=2
      ]
      \draw (0,10) rectangle (30,40);
      \node[] at (15,25) {X};
      \draw (10,0) -- (10,10) node [] at (10,-5) {\tiny{A}};
      \draw (20,0) -- (20,10) node [] at (20,-5) {\tiny{B}};
      \draw (8,3) -- (12,7) node[above left]{\tiny{4}};
      \draw (18,3) -- (22,7) node[above right]{\tiny{4}};
      \draw (13,43) -- (17,47) node[right]{\tiny{8}};
      \draw (15,40) -- (15,50) node [] at (15,55) {\tiny{P}};
    \end{tikzpicture}
    \caption{symbol}
    \label{pic:h-h-44-symb}
  \end{subfigure}
  \begin{subfigure}[b]{0.4\textwidth}
    \centering
    \begin{equation*}
      \begin{arithmetic}
              A_3  ~A_2  ~A_1  ~A_0 &\\
    \times    B_3  ~B_2  ~B_1  ~B_0 &\\
           A_3B_0A_2B_0A_1B_0A_0B_0 &\\
         A_3B_1A_2B_1A_1B_1A_0B_1~~ &\\
       A_3B_2A_2B_2A_1B_2A_0B_2~~~~ &\\
  +  A_3B_3A_2B_3A_1B_3A_0B_3~~~~~~ &\\
   P_7~~P_6~P_5~P_4~P_3~P_2~P_1~P_0~&
      \end{arithmetic}
    \end{equation*}
    \caption{function}
    \label{pic:h-h-44-func}
  \end{subfigure}
  \hfill
  \begin{subfigure}[b]{0.45\textwidth}
    \centering
    \includegraphics[width=\textwidth]{01-mult1.png}
    \caption{implementation}
    \label{pic:h-h-44-impl}
  \end{subfigure}
  \caption{4x4 multiplier}
  \label{pic:h-h-44-mult}
\end{figure}

\section{Представление дробных чисел}
\subsection{Дробные форматы}
\textbf{Q4.12 [-8, 8)}, $\varepsilon = 2^{-12} = 2,44 \times 10^{-4}$ целые числа, старшие разряд - по формуле, под разряды целых чисел отведено 4 разряда, причём самый старший - знак.
\begin{figure}[H]
  \setlength\tabcolsep{1.5pt}
  \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|} 
    $2^{3}$ & $2^{2}$ & $2^{1}$ & $2^{-0}$ & $2^{-1}$ & $2^{-2}$ & $2^{-3}$ & $2^{-4}$ & $2^{-5}$ & $2^{-6}$ & $2^{-7}$ & $2^{-8}$ & $2^{-9}$ & $2^{-10}$ & $2^{-11}$ & $2^{-12}$ \\ [0.5ex] 
    $15$ & $14$ & $13$ & $12$ & $11$ & $10$ & $9$ & $8$ & $7$ & $6$ & $5$ & $4$ & $3$ & $2$ & $1$ & $0$ \\ [0.5ex] 
    \hline
    S & X & X & X & X & X & X & X & X & X & X & X & X & X & X & X \\
    \hline
  \end{tabular}
\end{figure}
\[X_{Q4.12} = -s \cdot 2^3 + \sum_{i=0}^{14} x_i \cdot 2^{(-12+i)} = 2^{-12}\big(-s \cdot 2^{15} + \sum_{i=0}^{14} x_i \cdot 2^i \big) = 2^{-12} \cdot X_{Z16}\]

\textbf{Q1.15 [-1, 1)}, $\varepsilon = 2^{-15} = 3,05 \times 10^{-5}$ (используется чаще всего). Целая часть числа фактически состоит только из знака.
\begin{figure}[H]
  \setlength\tabcolsep{1.5pt}
  \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|} 
    $2^{0}$ & $2^{-1}$ & $2^{-2}$ & $2^{-3}$ & $2^{-4}$ & $2^{-5}$ & $2^{-6}$ & $2^{-7}$ & $2^{-8}$ & $2^{-9}$ & $2^{-10}$ & $2^{-11}$ & $2^{-12}$ & $2^{-13}$ & $2^{-14}$ & $2^{-15}$ \\ [0.5ex] 
    $15$ & $14$ & $13$ & $12$ & $11$ & $10$ & $9$ & $8$ & $7$ & $6$ & $5$ & $4$ & $3$ & $2$ & $1$ & $0$ \\ [0.5ex] 
    \hline
    S & X & X & X & X & X & X & X & X & X & X & X & X & X & X & X \\
    \hline
  \end{tabular}
\end{figure}
\[X_{Q1.15} = -s + \sum_{i=0}^{14} x_i \cdot 2^{(-15+i)} = 2^{-15}\big(-s \cdot 2^{15} + \sum_{i=0}^{14} x_i \cdot 2^i \big) = 2^{-16} \cdot X_{Z16}\]

\textbf{Q1.31 [-1, 1)}, $\varepsilon = 2^{-31} = 4,66 \times 10^{-10}$ аналогично, но увеличена точность
\[X_{Q1.31} = -s + \sum_{i=0}^{30} x_i \cdot 2^{(-31+i)} = 2^{31}\big(-s \cdot 2^{31} + \sum_{i=0}^{30} x_i \cdot 2^i \big) = 2^{-31} \cdot X_{Z32}\]

\textbf{Проблема работы с фиксированной запятой} состоит в том, что при умножении надо выполнять коррекцию результата, поскольку в результате умножения мы получили на 4 разряда больше, чем должен быть результат (разрядность результата умножения всегда в два раза больше разрядности исходных множителей)
\[0000,0001_2 = \frac{1}{16} = 0,625\]
\[0001,1000_2 = \frac{24}{16} = 1,5\]
\[\frac{a}{c} + \frac{b}{c} = \frac{a + b}{c}\]
\[\frac{a}{c} * \frac{b}{c} = \frac{{a * b} / c}{c}\]
\[1,5 * 2,5 = 3,75\]
\[0001,1000_2 * 0010,1000_2 = 0011,1100 | 0000_2\]

\subsection{Внутренний формат Q9.31}
\textbf{Q9.31 [-256, 256)}, $\varepsilon = 2^{-31} = 4,66 \times 10^{-10}$. АЛУ работает только с беззнаковыми числами, далее весь результат умножается на $2^{-31}$ чтобы получить знак. В двоичном представлении старший разряд ($-2^8$) является знаковым, далее с 38го по 31й представлена целочисленная часть, а с 30го по 0й разряды дробная (с точностью от $2^{-1}$ до $2^{-31}$). АЛУ на вход принимает числа и перенос, возвращает результат и флаги CF, OF, SF, ZF (переноса, переполнения, знака, нуля). Поскольку представление дробных чисел с фиксированной запятой совпадает с представлением целых чисел, то вычисления с фиксированной запятой можно представить в следующем виде:
\[X_{N40} = \sum_{i=0}^{39} x_i \cdot 2^i\]
\[X_{Z40} = -s \cdot 2^{39} + \sum_{i=0}^{38} x_i \cdot 2^i \]
\[X_{Q9.31} = -s \cdot 2^{8} + 2^{-31} \sum_{i=0}^{38} x_i \cdot 2^i \]
\[X_{Q9.31} = 2^{-31}\big( -s \cdot 2^{39} + \sum_{i=0}^{38} x_i \cdot 2^i \big) = 2^{-31} \cdot X_{Z40}\]
\[X_{Q9.31} \pm Y_{Q9.31} = 2^{-31} (X_{Z40} \pm Y_{Z40})\]

\textbf{Преобразование дробных} происходит аналогично целым числам при уменьшении разрядности - проверить старшие 9 разрядов на соответствие значению исходного, при увеличении разрядности - расширяем знак.
\[ X_{Q9.31} = -s \cdot 2^{8} + -2^{-31} \sum_{i=0}^{38} x_i \cdot 2^i \]
\[ X_{Q1.31} = -s + 2^{-31} \sum_{i=0}^{30} x_i \cdot 2^i \]
В данном случае сумма - это геометрическая прогрессия
\[ \sum_{i=0}^{n-1} aq^i = a\frac{q^n - 1}{q - 1} \]
Поэтому, преобразование в меньшую разрядность можно представить следующим образом:
\[ 2^{8} - \sum_{i=0}^{7} 2^i = 2^{8} - \frac{2^8 - 1}{2 - 1} = 2^{0} \]
А преобразование в б\'{о}льшую разрядность так:
\begin{equation*}
  \begin{gathered}
    X_{Q1.31} = -s \cdot 2^{0} + 2^{-31} \sum_{i=0}^{30} x_i \cdot 2^i =\\
    = -s\big(2^{8} - \sum_{i=0}^{7}2^i\big) + 2^{-31} \sum_{i=0}^{30}x_i \cdot 2^i =\\
    = -s \cdot 2^{8} + 2^{-31} \sum_{i=0}^{38} x_i \cdot 2^i
    \Bigg|\substack{x_{38} = s\\x_{37} = s\\...\\x_{31} = s}
  \end{gathered}
\end{equation*}

\subsection{Насыщение (Saturation)}
Когда происходят операции с плавающей запятой существуют случаи неопределённости, например, деление на ноль - это $\pm$ бесконечность, а $\frac{0}{0}$ неопределено. При операциях с фиксированной запятой такого быть не может, но если результат непредставим - мы преобразуем его на максимально возможное представимое число (при отрицательном результате заменяем на самое маленькое число, при положительном - на самое большое доступное).
\begin{table}[H]
  \centering
  \begin{tabular}{lclcl} 
    Q9.31            &           & Q1.31            &   &               \\ [0.5ex] 
    0xFE80\_0000\_09 & $\neq$    & 0x80\_0000\_09   &   &               \\ 
    0x0180\_0000\_09 & $\neq$    & 0x80\_0000\_09   &   &               \\
    Q9.31            &           & Q9.31            &   & Q1.31         \\ [0.5ex] 
    0xFE80\_0000\_09 & $\approx$ & 0xFF80\_0000\_09 & = & 0x80\_0000\_00\\ 
    0x0180\_0000\_09 & $\approx$ & 0x007F\_FFFF\_FF & = & 0x7F\_FFFF\_FF\\
  \end{tabular}
\end{table}

\textbf{0xFF80000000} – минимальное число в Q1.31

\textbf{0x007FFFFFFF} – максимальное число в Q1.31

\subsection{Умножение дробных}
Для приведения результата умножения Z32 в Q1.31 нужно умножить результат на два (сдвинуть на разряд влево). В целочисленной арифметике нельзя умножить два 16-разрядных числа и получить 16-разрядное (в результате умножения всегда получается большее по разрядности число). В числах с фиксированной точкой это реально, но Z32 нужно сдвинуть на 15 разрядов вправо (то есть проигнорировать младшие полученные разряды).
\begin{equation*}
  \begin{gathered}
X_{Q1.15} = -s_x + 2^{-15} \sum_{i=0}^{14} x_i \cdot 2^i,  Y_{Q1.15} = -s_y + 2^{-15} \sum_{i=0}^{14} y_i \cdot 2^i \\
Z = 2^{-30} \big( -s_x + 2^{15} \sum_{i=0}^{14} x_i \cdot 2^i\big) \big( -s_y + 2^{15} \sum_{i=0}^{14} y_i \cdot 2^i \big) \\
Z = 2^{-30}(X_{Z16} \cdot Y_{Z16}) = 2^{-30} Z_{Z32}, Z_{Q1.31} = 2 \cdot Z \\
Z_{Q1.31} = -s_Z + 2^{-31} \sum_{i=0}^{30} z_i \cdot 2^i \\
Z_{Q1.31} = Z_{Z32} < < 1 \\
Z_{Q1.15} = Z_{Z32} > > 15
  \end{gathered}
\end{equation*}

\begin{lstlisting}[language=C,style=CCodeStyle]
  int x, y;
  long z;
  x = 0xFDE3, y = 0x71A4;
  z = ((long) x * y) << 1;

  int x, y, z;
  x = 0xFDE3, y = 0x71A4;
  z = ((long) x * y) >> 15;
\end{lstlisting}

\subsection{Деление дробных}
Команды деления фактически нет. Но, делить числа иногда нужно, поэтому создаётся функция, которая реализует не сложения/сдвиги, а вычисляет корень функции методом касательной Ньютона: находим первое приближение, находим второе приближение производной первого приближения, рисуем касательную, значение получаем на оси Х. Повторяем фиксированное число раз.
\[f(x) = \frac{1}{x} - c, f(x) = 0 \to x = \frac{1}{c}\]
\[f(x) = 0, x_{m+1} = x_m - \frac{f(x_m)}{f'(x_m)} \]
\begin{figure}[H]
  \begin{tikzpicture}[thick,yscale=0.8]
    \draw[-latex,name path=xaxis] (-1,0) -- (12,0) node[above]{\large $x$};
    \draw[-latex] (0,-2) -- (0,8)node[right]{\large $y$};;

    \draw[ultra thick, orange,name path=function]  plot[smooth,domain=1:9.5] (\x, {0.1*\x^2-1.5}) node[left]{$F(x)$};

    \draw[dashed] (8,0) -- (8,4.9) node[circle,fill,inner sep=2pt]{};
    \draw[dashed, violet, name path=Tfunction]  plot[smooth,domain=4.25:9.5] (\x, {1.6*\x-7.9});

    \draw (8,0.1) -- (8,-0.1) node[below] {$x^{(m)}$};
    \draw [name intersections={of=Tfunction and xaxis}] ($(intersection-1)+(0,0.1)$) -- ++(0,-0.2) node[below,fill=white] {$x^{(m+1)}$} ;
  \end{tikzpicture}
\end{figure}

Получаем рекуррентное уравнение
\[x_{m+1} = 2x_m - x_m^2 c (|x_{m+1} - x_m | < \varepsilon) \]
Если представить С как мантиссу на 2-в-степени-порядка, известно, что мантисса будет от 1/2 до 1.
\[c = M \cdot 2^E, |M| \in [\frac{1}{2}, 1) \]
Запоминаем порядок и выполняем операцию с мантиссой. Чтобы получить требуемую погрешность нужно всего три итерации. Для того чтобы вычисление было быстрее - мы задаём правильное приближение.
\begin{equation*}
  \begin{gathered}
  M = 01XX...Xb, E=0YYY...Yb\\
  x_{m+1} = 2x_m - x_m^2 M (m = 0, 1, 2, 3)\\
  x_0 = (M < < 1)^{0x1FFF}\\
  E_0 = E - 1
  \end{gathered}
\end{equation*}

\begin{lstlisting}[language=C,style=CCodeStyle]
void ldiv16(LDATA *x, DATA *y, DATA *z, DATA *zexp, ushort nx);
\end{lstlisting}

\subsection{Формат с плавающей запятой}
Работает по стандарту IEEE 754 (1985) \footnote{https://habr.com/ru/post/112953/}
Формат подразумевает три поля (знак, 8(11) разрядов поля для смещённого порядка, 23(52) бита мантисса). Так как число может быть нормализовано поэтому старшая единица не хранится, но подразумевается.
\begin{table}[ht]
  \centering
  \begin{tabular}{|l|l|l|c|} 
    \hline
    S     & E  & M  & \\
    1     & 8  & 23 & $F_{32} (-1)^S 2^{(E-127)} (1+M/2^{23})$  \\
    1     & 11 & 52 & $F_{64} (-1)^S 2^{(E-1023)} (1+M/2^{52})$ \\
    \hline
  \end{tabular}
\end{table}

\begin{itemize}
\item [S] – Sign (знак числа)
\item [E] – Exponent (8 или 11 бит смещенного на 127 или 1023 порядка числа)
\item [M] – Mantissa (23 или 52 бита мантиссы, дробная часть числа)
\end{itemize}
Например: \code{0100 0011 0001 1011 1010 0000 0000 0000b 431BA000h}
\begin{table}[ht]
  \centering
  \begin{tabular}{|l|l|l|} 
    \hline
    S     & E                   & M\\
    0     & 10000110            & 00110111010000000000000b\\
    0     & 134                 & 1810432\\
    (-1)0 & $\cdot 2^{(134-127)}$ & $\cdot(1+1810432/2^{23})$ = 155,625\\
    \hline
  \end{tabular}
\end{table}

\includegraphics[width=150mm]{04-fpointvals.png}

Нули бывают как положительные, так и отрицательные, это касается только дробных, в целочисленных только +0 бывает. Зелёная зона - непредставимые числа (слишком большие для хранения внутри такой переменной) или настолько маленькие, что мнимая единица в мантиссе отсутствует. Бесконечность одна положительная, одна отрицательная, дальше идёт очень много не-чисел (если знать как, можно использовать нечисла для хранения собственных данных)

\textbf{Денормализованные числа}
5-разрядный формат с плавающей запятой.
\begin{table}[ht]
  \centering
  \begin{tabular}{|l|l|l|c|} 
    \hline
    S     & E  & M  & \\
    1     & 2  & 2 & $E: -1, 0, 1, 2 (-1 \leq E \leq 2) $  \\
          &    &   & $M: 1.00, 1.01, 1.10, 1.11 (1.00 \leq M \leq 1.11)$ \\
    \hline
  \end{tabular}
\end{table}
\begin{table}[ht]
  \centering
  \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|} 
    \hline
    0 & & 1 & & 2 & & 3 & & 4 & 5+ \\
    \hline
    \ver{00000} & 00001 & \ver{00100} & 00101 & \ver{01000} & \ver{01001} & \ver{01010} & \ver{01010} & \ver{01100} & E = 2\\
      & 00010 & & 00110 & & & & & & $M \neq 0$\\
      & 00011 & & 00111 & & & & & &до 01111\\
    \hline
    \multicolumn{2}{|l|} {Денормализованные} & \multicolumn{6}{l|}{Нормализованные} & $+\infty$  & Не числа \\
    \hline
  \end{tabular}
\end{table}

Проблемы чисел с плавающей запятой (вероятнее всего имеются ввиду указанные выше 5-разрядные переменные, и/или конкретный сигнальный процессор с его странными ограничениями, поскольку никакого подобного округления в нормальном программировании происходить не будет, \textit{прим. Овчинников})
\[ (0.5 + 1.0) + 3.5 = 5.0; 0.5 + (1.0 + 3.5) = 4 \]
На слайде показана числовая прямая, на которой после каждого действия во втором примере по какой-то причине происходит округление дробной части до целого. А в первом равенстве этого не происходит.

\textbf{Методы округления чисел с плавающей запятой}
\begin{itemize}
\item Round to nearest, ties to even - округление в сторону ближайшего, к чётному в случае конфликтов (режим по умолчанию в IEEE 754)
  \[ 01.101_2 \to 01.1_2, 01.110_2 \to 10.0_2, 01.111_2 \to 10.0_2, -01.101_2 \to -01.1_2 \]
\item Rount up - округление в сторону $+\infty$
  \[ 01.101_2 \to 10.0_2, 01.110_2 \to 10.0_2, 01.111_2 \to 10.0_2, -01.101_2 \to -01.1_2 \]
\item Rount down - округление в сторону $-\infty$
  \[ 01.101_2 \to 01.1_2, 01.110_2 \to 01.1_2, 01.111_2 \to 01.1_2, -01.101_2 \to -10.0_2 \]
\item Rount towards zero - округление в сторону 0
  \[ 01.101_2 \to 01.1_2, 01.110_2 \to 01.1_2, 01.111_2 \to 01.1_2, -01.101_2 \to -01.1_2 \]
\end{itemize}

\textbf{Арифметические проблемы}
\begin{itemize}
\item Не все числа имеют представление.
\item Преобразование в целые: $63,0/9,0 \to 7$, $0,63/0,09 \to 6$.
\item Преобразование в символьные форматы и обратно, многие числа нельзя ввести или вывести точно: $0,2 \to 0,200000000003$.
\item Порядок вычисления может влиять на результат и его точность: не выполняются законы ассоциативности и дистрибутивности.
\item Проблемы сравнения: $x == y$.
\end{itemize}

\textbf{Рекомендации}
\begin{itemize}
\item Выполнять вычисления в одном формате чисел.
\item Избегать лишних преобразований форматов.
\item При сравнении чисел F32, F64 использовать $abs(x − y) \leq \varepsilon$.
\item Избегать сложений чисел, экспоненты которых сильно отличаются.
\item Избегать вычитания близких чисел.
\item Функции exp, log, sin и т.д. не вычисляются точно.
\end{itemize}

\section{Сигнальные микропроцессоры}
Сигнальные микропроцессоры занимаются обработкой только массивов данных фиксированной длины. В отличие от процессоров общего нащначения. Архитектура микропроцессоров общего назначения почти не изменилась со времён х386, суперскалярная архитектура.
\begin{figure}[ht]
  \centering
  \includegraphics[width=15cm]{05-intel.png}
\end{figure}

У таких процессоров есть особенная надстройка - NUMA (non uniform memory access) - нерегулярный доступ ко внешней памяти. помогает сохранить консистентность кэшей. Архитектура является довольно сложной как в реализации, так и в программировании.

Основное преимущество сигнальных процессоров для своих функций в том, что они специализируются на решении единственной задачи - вычисление суммы произведений двух векторов. То есть СП специально спроектирован именно для сигнальной обработки данных. По сути все виды обработки сигналов - это умножение и сложение. Для использования этих операций есть АЛУ для сложения, АЛУ для умножения и аккумулятор. Так как исходные тоже должны сохраняться в память - есть несколько магистралей (векторов) для чтения данных. Все магистрали подключены к шине памяти, то есть все операции фактически находятся во внутренней памяти. одновходовая и двухвходовая шина подключается ко внутренней памяти процессора. Это позволяет выполнять фильтрацию двух сигналов с одинаковыми коэффициентами. Это позволяет вычислять такое множество операций за один такт. и сохранять/читать команды/данные из внешней памяти.

Российскими производителями представлены:
\begin{itemize}
\item 1967ВН044 – 32-разр. ЦОС, 230 МГц, КМОП 0,18 мкм (Миландр)
\item 1890ВМ7Я – 32-разр. ЦОС, 200 МГц, КМОП 0,18 мкм (НИИСИ РАН)
\item 1901ВЦ1Т – 2 ядра: 16-разр. ЦОС и 32-разр. RISC ARM, 100 МГц, КМОП 0,18 мкм (Миландр)
\item 1892ВМ7Я – 5 ядер: 4 ядра 32-разр. ЦОС, 32- разр. RISC MIPS, 200 МГц, КМОП 0,13 мкм (НПЦ ЭЛВИС)
\item 1879ВМ8Я – 5 ядер: 4 ядра 64-разр. ЦОС, 32- разр. RISC ARM, 1000 МГц, КМОП 0,28 мкм (НТЦ Модуль)
\end{itemize}

\nomenclature[A]{SRAM}{Static Random Access Memory (статическая память)}
\nomenclature[A]{DMA}{Direct Memory Access (прямой доступ к памяти)}
\nomenclature[A]{BKP}{Backup (архивирование)}
\nomenclature[A]{OSC}{Oscillator (генератор)}
\nomenclature[A]{IWDG}{Independent Watch Dog (сторожевой таймер)}
\nomenclature[A]{WWDG}{Windowed Watch Dog (оконный сторожевой таймер)}
\nomenclature[A]{AHB}{Advanced High-performance Bus (внутренняя шина)}
\nomenclature[A]{McBSP}{Multichannel Buffered Serial Port (последовательный порт)}
\nomenclature[A]{MIPS}{Microprocessor without Interlocked Pipeline Stages}

\includegraphics[width=15cm]{05-1967vn044.png}

Важной особенностью является, что у этого (1967ВН044) микропроцессора есть аппаратный конвейер, позволяющий выполнять части команд параллельно. У сигнальных микропроцессоров всегда есть довольно большая внутренняя память с четырьмя каналами доступа, чтобы данные очень быстро передавать на обработку. 

В курсе будет идти работа с микропроцессором TMS320C5515
\begin{itemize}
\item Тактовая частота 60 (75, 100, 120) МГц
\item Напряжение питания ядра 1,05 и 1,30 В
\item Мощность потребления 18,0-26,4 мВт
\item Быстродействие 240 миллионов команд
\item Конвейер 12 стадий, 2 команды параллельно
\item Данные с фиксированной запятой 16, 32, 40 бит
\item Встроенная основная память 320 КБ
\item Встроенная постоянная память 128 КБ
\item Внешняя память до 16 МБ
\item Периферийные устройства DMA, I2C, SPI, I2S, UART, USB, MMC/SD, GPIO, SAR, LCD
\end{itemize}

На процессорах общего назначения это невозможно, поскольку быстродействие при такой частоте невозможно. но у сигнального микропроцессора есть 12-стадийный конвейер, что позволяет выполнять одну команду за пол-такта. Мощность потребления исчезающе мала, поэтому удобно использовать от аккумулятора. Включает в себя множество периферийных интерфейсов, сравнимых с обычным микропроцессором общего назначения.

Внутри ядра ЦОС имеется специально встроенный вычислитель быстрого преобразования фурье. 16 каналов прямого доступа к памяти. Поскольку есть dual access и single access RAM - появляется три канала получения данных. ко внутренним шинам мультиплексируются внешние подключаемые периферийные устройства.

\nomenclature[P]{CPU}{Central Processing Unit (центральное процессорное устройство, центральный процессор)}
\nomenclature[P]{Core}{ядро, центральная часть}
\nomenclature[P]{Bus}{шина, магистраль}
\nomenclature[P]{MMR}{Memory Mapped Register (регистр отображенный в память)}
\nomenclature[P]{INT}{Interrupt (прерывания)}
\nomenclature[P]{LDO}{Low-Drop Out (линейный регулятор с низким падением напряжения)}
\nomenclature[P]{JTAG}{Joint Test Action Group (специализированный аппаратный интерфейс для тестирования и отладки сложных дискретных устройств)}
\nomenclature[P]{FFT}{Fast Fourier Transform (быстрое преобразование Фурье)}

\nomenclature[M]{RAM}{Random Access Memory (память со случайным доступом, ОЗУ – оперативное запоминающее устройство, основная память)}
\nomenclature[M]{mSDRAM}{Mobile Synchronous Dynamic RAM (мобильная синхронная динамическая память со случайным доступом)}
\nomenclature[M]{DARAM}{Dual Access RAM (двухвходовая основная память)}
\nomenclature[M]{SARAM}{Single Access RAM (одновходовая основная память)}
\nomenclature[M]{ROM}{Read Only Memory (память только для чтения, ПЗУ – постоянное запоминающее устройство)}
\nomenclature[M]{EEPROM}{Electrically Erasable Programmable ROM (электрически стираемое перепрограммируемое ПЗУ, флэш-память)}
\nomenclature[M]{EHPI}{Enhanced Host-Port Interface (интерфейс с другим процессором)}

\nomenclature[I]{LCD}{Liquid crystal display (жидкокристаллический дисплей)}
\nomenclature[I]{MMC/SD}{Multi Media Card/Secure Digital (мультимедийная карта / безопасная цифровая карта)}
\nomenclature[I]{SAR}{Successive Approximation Register (регистр последовательного приближения)}

\begin{figure}[h]
  \centering
  \includegraphics[width=15cm]{05-core.png}
  \caption{Ядро микропроцессора}
  \label{pic:dsp-core}
\end{figure}

Функциональная диаграмма ядра микропроцессора на рисунке \hrf{pic:dsp-core} показана без модуля быстрого преобразования Фурье. У процессора нет байтовых данных. Все данные в словах, однако, код программы принимается и обрабатывается в байтах. Сам процессор внутри состоит из 4х модулей:
\begin{itemize}
\item операционное устройство Д-модуль, не занимается адресацией
\item адресацией занимается только специальное устройство А-модуль
\item адрес для команд формируется специальным Р-модулем
\item чтение не происходит явно, все команды сразу пишутся в I-модуль.
\end{itemize}
Это разные устройства, они разделены физически, у них есть регистровые файлы, но у них есть взаимосвязи. Основное общение устройств происходит через шины адреса и данных, иногда одни устройства могут задействовать простаивающие ресурсы других (например, может быть задействован умножитель из операционного устройства для вычисления адреса)

\begin{wrapfigure}{l}{0.4\textwidth}
  \includegraphics[width=0.35\textwidth]{05-triread.png}
\end{wrapfigure}

Как именно происходит тройное чтение и двойная запись: данные поступают на два независимых АЛУ и сохраняют данные по независимым шинам (2 команды, 2 параллельных процесса обработки данных), управление АЛУ происходит независимо по шине команд, в случае необходимости одно из АЛУ пишет в SARAM. Фактически, команда, подаваемая на АЛУ определяет, куда будут переданы результаты вычислений АЛУ

\subsection{Адресные пространства}
\begin{table}[ht]
  \renewcommand{\arraystretch}{0.5}
  \centering
  \begin{tabular}{R|C|L} 
    \cline{2-2} 000000h & Внутренняя MMR & 192б \\ 
    \cline{2-2} 0000C0h & Внутренняя DARAM & 64Кб - 192б \\ 
    \cline{2-2} 010000h & Внутренняя SARAM & 256Кб \\ 
    \cline{2-2} 050000h & Внешняя синхронная CS0-1 & 8Мб - 320Кб \\ 
    \cline{2-2} 800000h & Внешняя асинхронная CS2 & 4Мб \\ 
    \cline{2-2} C00000h & Внешняя асинхронная CS3 & 2Мб \\ 
    \cline{2-2} E00000h & Внешняя асинхронная CS4 & 1Мб \\ 
    \cline{2-2} F00000h & Внешняя асинхронная CS5 & 1Мб - 128Кб \\ 
    \cline{2-2} FE0000h & ROM (MPNMC=0)+ Резерв(MPNMC=1) & 128Кб \\ 
    \cline{2-2} \multicolumn{3}{L}{FFFFFFh}  \\ 
  \end{tabular}
\end{table}

В микропроцессорах, предназначенных для цифровой обработки сигналов, есть два адресных пространства. Плавающих адресов нет, потому что состав устройств постоянный.

\begin{table}[ht]
  \renewcommand{\arraystretch}{0.5}
  \centering
  \begin{tabular}{R|C|} 
    \cline{2-2} 0000h & Управление простоем (Idle Control)\\
    \cline{2-2} 0C00h & Канал прямого доступа DMA0\\
    \cline{2-2} 0D00h & Канал прямого доступа DMA1\\
    \cline{2-2} 0E00h & Канал прямого доступа DMA2\\
    \cline{2-2} 0F00h & Канал прямого доступа DMA3\\
    \cline{2-2} 1000h & Интерфейс внешней памяти EMIF\\
    \cline{2-2} 1800h & Таймер Timer0\\
    \cline{2-2} 1840h & Таймер Timer1\\
    \cline{2-2} 1880h & Таймер Timer2\\
    \cline{2-2} 1900h & Часы реального времени RTC\\
    \cline{2-2} 1A00h & Контроллер I2C\\
    \cline{2-2} 1B00h & Контроллер UART\\
    \cline{2-2} 1C00h & Управление микропроцессором\\
    \cline{2-2} 2800h & Контроллер I2S0\\
    \cline{2-2} 2900h & Контроллер I2S1\\
    \cline{2-2} 2A00h & Контроллер I2S2\\
    \cline{2-2} 2B00h & Контроллер I2S3\\
    \cline{2-2} 2E00h & Контроллер LCD\\
    \cline{2-2} 3000h & Контроллер SPI\\
    \cline{2-2} 3A00h & Контроллер MMC/SD0\\
    \cline{2-2} 3B00h & Контроллер MMC/SD1\\
    \cline{2-2} 7000h & Аналогово-цифровой преобразователь SAR\\
    \cline{2-2} 8000h & Контроллер USB\\
    \cline{2-2} \multicolumn{2}{L}{FFFFh}  \\ 
  \end{tabular}
\end{table}

\textbf{(слайды с 20 по 26 на лекции не объяснялись)}

\subsection{Операционное устройство}
\subsubsection{Физическое устройство}
Как видно на рисунке \hrf{pic:dsp-core}, от магистрали BB, CB, DB есть три входа в операционное устройство. Модуль работает с операндами, находящимися в памяти (стрелки к A-модулю и P-модулю). Прямо в коде могут быть команды, полученные из буфера команд. То есть можем обрабатывать данные, находящиеся в любом регистре любого модуля. Ответы уходят к EB и FB.

\begin{figure}[ht]
  \centering
  \includegraphics[width=10cm]{06-oper-phys.png}
  \caption{Операциооное устройство}
  \label{pic:dsp-dunit}
\end{figure}

Операционное устройство - это чать ядра микропроцессора. Видно, что операционное устройство не обрабатывает адреса, адреса получаем из устройства адресации, операционное устройство они не касаются. Все данные содержатся в регистровом файле. Арифметико-логический блок выполняет арифметико-логические операции. Также есть двойной умножитель-аккумулятор. Часто нужно выполнять операцию сдвига, поэтому есть сдвигатель. Важный блок - блок битовых операций. Адрес бита - это адресуемая область в 40 разрядов из ячейки памяти. Операционное устройство взаимодействует с другими модулями. Может хранить свои данные в A, P и I модулях. При этом, например, из АЛУ данные брать нельзя.

\includegraphics[width=10cm]{06-blocks-conn.png}

Блоки соединены параллельно. Регистровый файл со всего четырьмя основными аккумуляторами, два 17-битных умножителя, один 40-битный АЛУ и сдвигатель, то есть многое можно выполнить параллельно. Все модули работают параллельно, но не все данные можно одновременно подавать везде. этим Арифметико-логический блок похож на архитектуру VLIW.

\subsubsection{Регистровый файл}
Изображён на рисунке \hrf{pic:dsp-dunit}
\begin{itemize}
\item Хранение промежуточных данных D модуля
\item Двухсторонний обмен данными с блоками D модуля
\item Запись непосредственных данных из кода команды I модуля
\item Обмен промежуточными данными с модулями I, P, A и памятью
\end{itemize}

\begin{table}[ht]
  \centering
  \begin{tabular}{R|C|C|C|} 
        & 39-32 & 31-16 & 15-0 \\ 
    \cline{2-4}
    AC0 & AC0G  & AC0H  & AC0L \\ 
    AC1 & AC1G  & AC1H  & AC1L \\ 
    AC2 & AC2G  & AC2H  & AC2L \\
    AC3 & AC3G  & AC3H  & AC3L \\
    \cline{2-4}
  \end{tabular}
\end{table}
\begin{itemize}
\item Регистры-аккумуляторы AC0, AC1, AC2, AC3 (Accumulators, Low, High, Guard)
\item Переходные регистры TRN0, TRN1 (TRaNsition registers)
\end{itemize}

\subsubsection{Арифметико-логический блок}
\begin{itemize}
\item Получение непосредственных данных от I модуля
\item Двухсторонний обмен данными с регистрами модуля A и D, а также с ячейками памяти
\item Арифметические операции с данными в формате N40, Z40, Q9.31
\item Многоразрядные логические операции
\end{itemize}

\textbf{Операции арифметико-логического блока}

\begin{wrapfigure}{r}{0.45\textwidth}
  \begin{tikzpicture}
    \draw (0,0)coordinate (O)--++(30:1)coordinate (A)--++(90:2)coordinate (B)--++(150:1)coordinate (C)--cycle;
    \draw [->]($(A)!0.5!(B)$)--++(0:1)node[right]{$Z(N40)$};
    \draw [->]($(O)!0.5!(A)$)--++(-90:1)--++(0:2)node[right]{$CF, OF$};
    \draw [->]($(O)!0.25!(A)$)--++(-90:1.5)--++(0:2.25)node[right]{$SF$};
    \draw [->]($(O)!0.75!(A)$)--++(-90:0.5)--++(0:1.75)node[right]{$ZF$};
    \draw [<-]($(B)!0.5!(C)$)--++(90:0.5)--++(180:1.75)node[left]{$C_0$};
    \draw [<-]($(C)!0.33!(O)$)--++(180:0.5) node[left]{$X(N40)$};
    \draw [<-]($(C)!0.67!(O)$)--++(180:0.5) node[left]{$Y(N40)$};
  \end{tikzpicture}
\end{wrapfigure}

АЛБ работает с натуральными числами, но мы можем интерпретироать результат как работу с числами с фиксированной запятой. Выполняет следующие операции:
\begin{itemize}
\item Поразрядные логические:
  \begin{itemize}
  \item отрицание – NOT; 
  \item конъюнкция – AND; 
  \item дизъюнкция – OR; 
  \item неэквиваленция – XOR.
  \end{itemize}
\item Арифметические:
  \begin{itemize}
  \item изменение знака NEG; 
  \item абсолютное значение ABS; 
  \item сложение ADD;
  \item вычитание SUB;
  \item вычитание и сложение SUBADD; 
  \item сложение и вычитание ADDSUB; 
  \item сравнение CMP;
  \item сравнение с конъюнкцией CMPAND; 
  \item сравнение с дизъюнкцией CMPOR; 
  \item максимум MAX, MAXDIFF; (maxdiff получаем максимальное из трёх)
  \item минимум MIN, MINDIFF.
  \end{itemize}
\item Округления:
  \begin{itemize}
  \item округление – ROUND;
  \item насыщение – SAT. (если есть переполнение для знакового или переноса для беззнакового делаем адекватный результат)
  \end{itemize}
\end{itemize}

\subsubsection{Битовый блок}
\begin{itemize}
\item Выполнение операций манипуляции двоичными разрядами (битами): сброс, установка, инверсия (по его адресу), проверка.
\item Подсчет числа бит (за один такт, параллельно на комбинационной схеме)
\item Выполнение операций над битовыми полями (экономит скорость для битовых операций)
\item Нормализация чисел в формате с фиксированной запятой
\end{itemize}

Адресация бит в регистрах: Используются те же методы, что и для адресации слов в памяти, например: \#3 – номер бита 3, *AR0+ – номер бита в регистре AR0 с увеличением на 1.

\begin{itemize}
\item Битовые операции:
  \begin{itemize}
  \item очистка бит – BCLR;
  \item инверсия бит – BNOT;
  \item установка бит – BSET;
  \item проверка бит – BTST;
  \item проверка битовой пары – BTSTP;
  \item установка бит с проверкой – BTSTSET;
  \item очистка бит с проверкой – BTSTCLR; 
  \item инверсия бит с проверкой – BTSTNOT.
  \end{itemize}
\item Операции с битовыми полями:
  \begin{itemize}
  \item извлечение бит BFXTR; (на слайде справа)
  \item расширение бит BFXPA; 
  \item число бит – BCNT. (те биты, которые считаются - это данные непосредственно в коде команды)
  \end{itemize}
\item Операции нормализации:
  \begin{itemize}
  \item порядок EXP; (выясняем число сдвигов, например, в зависимости от значений У нужно сдвинуть число, чтобы оно не потеряло значения. нормализуем число, преобразуем к числу с фиксированной запятой)
  \item мантисса и порядок MANT::NEXP. (кроме порядка получает ещё и сдвинутую на нужное числу мантиссу)
  \end{itemize}
\end{itemize}

(06-11)
\begin{itemize}
\item Арифметические сдвиги 40-разрядных данных в форматов N40, Z40, Q9.31 от -31 до 32 разряда.
\item Арифметические сдвиги 16-разрядных данных форматов N16, Z16, Q1.15 от -31 до 32 разряда и сохранение результата в аккумуляторе.
\item Циклические сдвиги 16- и 40-разрядных данных в регистрах AC0-AC3 и TRN0, TRN1
\end{itemize}

(06-12)
Циклические сдвиги: влево ROL; вправо ROR.
F1, F2: CARRY, TC1, TC2
\begin{lstlisting}[language=C,style=CCodeStyle]
  unsigned int x, y;
  x = (x & 0x1 ? 0x8000 : 0) | y >> 1;
  y = (y & 0x8000 ? 0x1 : 0) | y << 1;
\end{lstlisting}

Логические сдвиги: влево-вправо SFTL.
\begin{lstlisting}[language=C,style=CCodeStyle]
  unsigned int x, y;
  x = x << 3; y = y >> 2;
\end{lstlisting}

Арифметические сдвиги: shts влево-вправо SFTS.
\begin{lstlisting}[language=C,style=CCodeStyle]
  signed int x, y;
  x = y << 3; y = y >> 2;
\end{lstlisting}

(06-13)
Используются два 17-разрядных умножителя. Умножитель работает с 4мя форматами данных. форматы задаются 2мя флагами - знак-беззнак (sxmd) и целые-дробные (frc).
\begin{itemize}
\item Предварительное преобразование множителей в 17-разрядный формат (16 разрядов числа и один разряд знака).
\item Выполнение одинарных и двойных операций умножения со сложением (вычитанием) целых со знаком (SXMD=1) и без знака (SXMD=0), а также и дробных чисел (SXMD=1, FRC=1).
\end{itemize}
Примечание. 17-ти разрядный умножитель требуется для умножения целых чисел со знаком (флаг расширения знака SXMD равен нулю).

(06-14)
первоначально выполняется коррекция результата (умножение на два), для этого используется 32 и 16й разряд. не можем подать 4 операнда, поэтому умножитель должен быть общий.
ACx, ACz,(40 разрядов): AC0, AC1, AC2, AC3 Ty, Tz (16 разрядов): T0, T1, T2, T3
mac: ACx = ACy + (ACx * Tz )
mac: ACy = (ACy * Tz ) + ACx
когда один из операндов константный
mack: ACy = ACx + (Tz * k8)
mack: ACy = ACx + (Tz * k16)


Встроенный параллелизм:
\begin{itemize}
\item MAC::MAC, MAC::MAS, MAC::MPY; 
\item MAS::MAC, MAS::MAS, MAS::MPY; 
\item MPY::MAC, MPY::MAS, MPY::MPY.
\end{itemize}

Умножение – mpy (multiply)
Умножение со сложением (вычитанием) – mac (mas) (multiply and accumulate (subtract))

(06-15)
Подстановочные функции
\begin{lstlisting}[language=C,style=CCodeStyle]
  int _sadd(int, int)
  long _lsadd(long, long)
  long long _llsadd(long long, long long)
  int _ssub(int, int)
  long _lssub(long, long)
  long long _llssub(long long, long long)
  int _smpy(int, int)
  long _lsmpy(int, int)
  long _smac(long, int, int)
  long _smas(long, int, int)
  int _abss(int)
  long _labss(long)
  long long _llabss(long long)
  int _sneg(int)
  long _lsneg(long)
  long long _llsneg(long long);
  long _smpyr(int, int)
  long _smacr(long, int, int)
  long _smasr(long, int, int)
  int _norm(int)
  int _lnorm(long)
  long _rnd(long)
  int _sshl(int, int)
  long _lsshl(long, int)
  int _shrs(int, int)
  long _lshrs(long, int)
\end{lstlisting}

например, \code{\_sadd:}
\begin{lstlisting}[language=C,style=CCodeStyle]
  BSET SATA
  ADD T1, T0
  BCLR SATA
  RET
\end{lstlisting}

\subsection{Устройство адресации (07)}
02. используется для формирования адресов на пяти шинах (все, кроме адреса для программ). чтобы операционное устройство записывало свои данные, которые вычислило в правильные места.

03. используется магистралями данных, чтобы можно было использовать данные в регистровый файл и алу. имеется свой алу, который нужен для формирования сложных адресов. 

04. регистровый файл используется для
\begin{itemize}
\item Хранение промежуточных данных
\item Предоставление операндов и получение результатов операций
\item Обмен промежуточными данными с другими модулями и памятью
\end{itemize}

В файле есть регистры
Регистры страниц данных:
DPH (7 бит), DP (16 бит), PDP (9 бит).
Регистры-указатели:
XSP (23 бита), XSSP (23 бита), XARx (8*23 бита), XCDP (16 бит).
Регистры циклического буфера: BSAxx (5*16 бит), BKxx (3*16 бит).
Временные регистры: Tx (4*16 бит).

в РУ и ВР используются аргументы функции.

05. генератор адресов
• Формирование физических адресов операндов
• Передача физических адресов на шины адреса для чтения и для записи данных

06. АЛбА
• Сложение, вычитание, сравнение адресов. для умножения есть Д-юнит с двумя умножителями
• Логические и битовые операции с адресами
• Операции арифметических, логических и циклических сдвигов адресов
• Операции модификации регистров в косвенных методах адресации

07. Регистры модуля А.
Регистры страниц данных (23 и 9 бит)
\begin{itemize}
\item DPH, DP - Data Page (High) 
\item PDP - Peripheral Data Page
\end{itemize}
Регистры-указатели (23 бита)
\begin{itemize}
\item CDPH, CDP - Coefficient Data Pointer (High)
\item SPH, SP, SSP - (System) Stack Pointer (High) в системе есть два независимо работающих аппаратных стека.
\item XAR0-XAR7 - Extended Auxiliary Registers
\end{itemize}
Регистры циклического буфера (16 бит)
\begin{itemize}
\item BK03, BK47, BKC - Buffer size registers
\item BSA01, BSA23, BSA45, BSA67, BSAC - circular Buffer Start Address registers
\end{itemize}
Временные регистры (16 бит)
\begin{itemize}
\item T0-T3 - Temporary registers
\end{itemize}

08. Регистры страниц данных
нужен чтобы оперировать короткими адресами относительно страницы, заданной в этом регистре. механизм «начальных адресов» в сигнальном режиме. по адресу 2Б находится старшая часть адреса страницы данных.

Адресуем слова. если бы адресовали байты, то младший бит всегда был 0, поскольку слова это два байта и начало слов всегда было бы чётным. 

00 002Bh – 23-разрядный адрес 16-разрядного слова данных (BAB, CAB, DAB)
00 002Bh – 0000 0000 0000 0000 0010 1011 – адрес слова

09. Регистры-указатели.
нельзя обратиться куда-то в область памяти, чтобы прочитать AR0H-AR7H. Поскольку мы не можем туда писать, если произошедший сбой запишет туда данные, получим ошибки адресаций.

10. Временные регистры

11. Регистры циклического буфера. Чтобы не нужно было писать на С код
\begin{lstlisting}[language=C,style=CCodeStyle]
#define H 131
#define BK 1024
int h[H], x[BK];
y[BK], s;

for (t = 0, t++, t < BK) {
    s = 0;
    for (i = 0; i++; i < H) {
        s += ((long) h[i] * x[(t - i + BK) % BK]) >> 15;
    }
    y[t] = s;
}
\end{lstlisting}

адреса считаются по формуле

\[
  y (\tau) = \sum_{i=0}^{H-1} h(i) \times x(\tau - i)
\]

и есть регистры, которые проверяют адресацию. для каждой группы регистров есть свои регистры размера и начального адреса.

12. Методы адресации
непоср = команда находится в операнде
абсолют = адрес находится в коде команды
регистровая = в коде команды хранится регистр, а в регистре операнд
прямая = в команде есть смещение, добавляем к подразымеваемому базовому адресу
косвенная = в регистре адрес
базовая = в команде есть регистр и смещениее
бит-реверсивность это обратное распространение переноса при сложении, для БПФ.
циклическая когда указывается регистр относительно которого производим адресацию, остальное - по-умолчанию.

13. Прямая адресация
если в сигнальной обработке стек не используется как привычно и команда засылает в регистр Т0 операнд, который отсчитывается смещением. память линейная, а не стековая. в режиме компилятора КПЛ 0 даже сложение упраздняется, и внутри стека используется прямая адресация. 
\begin{verbatim}
CPL=0: MOV @2, T0 -> MOV *DP(2), T0
CPL=1: MOV @2, T0 -> MOV *SP(2), T0
\end{verbatim}

14. Косвенная адресация
адрес хранится прямо внутри регистра с модификацией адреса во время разрешения
\begin{table}[h!]
  \centering
  \begin{tabular}{||p{25mm}|p{150mm}||}
    \hline
Операнд & Модификация\\
    \hline
*ARx, *CDP & ARx, CDP не изменяется\\
*ARx+, *CDP+ & XARx, CDP увеличивается на 1 (2)\footnote{Изменение регистра на 1 происходит, если операнд слово, на 2 – если двойное слово} после генерации адреса\\
*ARx–, *CDP– & XARx, CDP уменьшается на 1 (2) --сноска1 после генерации адреса\\
*+ARx & XARx увеличивается на 1 (2) --сноска1 перед генерацией адреса\\
*–ARx & XARx уменьшается на 1 (2) --сноска1 перед генерацией адреса\\
*(ARx + T0), *(ARx + T0B)\footnote{Режим адресации с обратным порядком бит, при котором 0 бит – старший, а 15 (31, 39) – младший;} & XARx увеличивается на T0 после генерации адреса\\
*(ARx – T0), *(ARx – T0B)--сноска2 & XARx уменьшается на T0 после генерации адреса\\
*ARx(T0) & XARx не изменяется, T0 используется как базовый\footnote{При базовой адресация адрес операнда равен XARx плюс T0, расширенный со знаком до 23 бит}\\
*(ARx + T1) & XARx увеличивается на T1 после генерации адреса\\
*(ARx – T1) & XARx уменьшается на T1 после генерации адреса\\
*ARx(T1) & XARx не изменяется, T1 используется как базовый--сноска3\\
*ARx(\#k16), *CDP(\#k16) & XARx, CDP не изменяется, k16 используется как смещение\footnote{Адрес операнда равен XARx плюс k16, расширенная со знаком до 23 бит.}\\
*+ARx(\#k16) ,*+CDP(\#k16) & XARx, CDP увеличивается на k16 перед генерацией адреса\\
    \hline
  \end{tabular}
  \caption{Table to test captions and labels.}
  \label{table:1}
\end{table}

15. Циклическая адресация.

Её надо включать в регистре АР1. используется специльная команда для загрузки адреса и смещения.

; Размер циклического буфера в BK03
; Настройка циклической адресации через AR1
; Загрузка номера страницы в AR1H и очистка AR1
; Загрузка стартового адреса буфера в BSA01
; Пересылка в AC0 из 01 0A02 + AR1 = 01 0A02h
; Пересылка в AC0 из 01 0A02 + AR1 = 01 0A03h
; Пересылка в AC0 из 01 0A02 + AR1 = 01 0A04h
; Пересылка в AC0 из 01 0A02 + AR1 = 01 0A02h


16. Бит-реверсивная адресация
Как вычисляется БПФ? по формуле
\[ c(i) = \sum_{\tau=0}^{N-1} x(\tau) \times \omega_N^i(\tau), \omega_N^i = exp(-2\pi ji\tau / N), \omega_N^i = exp(-2\pi ji / N) \]
Примечание. Реализована путем сложения (вычитания) с обратным распространением переноса (заема).

по этой формуле получается, что
  01100000 (+0)
+ 00000100
= 01100100 (+4) + 00000100
= 01100010 (+2) + 00000100 ..перенос ушёл не влево, а вправо
= 01100110 (+6) + 00000100
= 01100001 (+1) + 00000100
= 01100101 (+5) + 00000100
= 01100011 (+3) + 00000100
= 01100111 (+7)
индексы выборки из массива получаем обратным распространением переноса. алгоритм требует непоследовательной выборки данных.

17. режимы адресации меняются относительно режима работы процессора. прямоугольниками выделены режимы в виде прямой адресации и пропадают при переходе из сигнального режима в обычный и наоборот.

18. Кодирование адресов при разных способах адресации
\begin{itemize}
\item Непосредственная: \#k3, ..., \#k16, \#k16, \#k23.
\item Абсолютная: *abs(\#a16) [DPH], *\#a23, port(\#a16). // старшая часть берётся из регистра DPH
\item Регистровая: ACx, TRNx, Tx, ARx, CDP, ...
\item Прямая: @a7 [XDP, XSP], port(@a7) [PDP].
\item Косвенная:*ARx, *CDP, *ARx$\pm$, *CDP$\pm$, *$\pm$ARx.
\item Базовая: *ARx(k16), *CDP(k16), *+ARx(k16).
\item Индексная: *ARx(Tx), *(ARx$\pm$Tx), *+CDP(k16).
\item Циклическая: [CR.] *ARx$\pm$,*$\pm$ARx,*(ARx$\pm$Tx), *CDP$\pm$, *+ARx(k16), *+CDP(k16) [BSAxx, BKxx].
\end{itemize}
19. Примеры адресации
• Непосредственная адресация \#: - константа (k3, k4, k5, k6);
- байт (K8, k8);
- слово (k9, k12, k16, K16);
- полуторное слово (k23).
MOV \#1Fh, DPH
• Регистровая адресация R.
BCLRAR0, AC0
• Абсолютная адресация *\#:
- *abs(\#a16); - *\#a23;
- port(\#a16).
PSH *abs16(\#1234h)
• Прямая адресация @a7:
- через DP @a7 (CPL=0); - через SP @a7 (CPL=1); - через PDP port(@a7);
- битовая @k5.
MOV @\#–12, T0
AND \#FFEFh, port(@\#1232h)
BTST @30, AC3
•
Косвенная адресация *R, *±R, *R±: - не модифицирующая *R;
- постфиксная *R+, *R-;
- префиксная *+R, *-R.
MOV *CDP+, T2
BSET *-AR2, AC1
• Базовая адресация *+R(k16):
•
-немодифицирующая *R(k16); - модифицирующая *+R(k16).
MOV AR3, high\_byte(*CDP(\#4))
BNOT *+AR4(\#3), AC2
Индексная адресация *(R±R), *R(R): - знаковая *R(R);
- беззнаковая *(R±R);
- реверсивная *(R±RB).
MOV *AR1(T1) < < \#16, AC0 MAS *(AR6–T0), *CDP, AC2 BNOT *(AR2+T0B), AC3
Циклическая адресация. ADD.CR dual(*CDP+), AC0, AC1
•
BSET *(AR7+T0), AR5

20. Мнемоника команд
BTSTCLR k4, Smem, TCx
MOV HI(ACy < < T2), Ymem
MOV [uns(]high\_byte(Smem)[)], dst
MOV high\_byte(Smem) < < \#SHIFTW, ACx
ADD.CR dual(Lmem), ACx, Acy
MPY[R][40] [uns(]Ymem[)], [uns(]Cmem[)], Acx
MOV [uns(] [rnd(]HI[(saturate](ACx < < Tx)[)))], Smem
Smem, Lmem, Cmem, Xmem, Ymem – метод адресации операнда в памяти Baddr – метод адресации бита в регистре
kx (Kx) – непосредственная беззнаковая (знаковая) константа разрядности x U, uns – беззнаковый операнд
low\_byte (high\_byte) – младший (старший) байт \#SHIFTW – знаковая константа числа сдвигов mmap() – память отображения регистров
port() – адресное пространство ввода-вывода dbl – 32-разрядный операнд в памяти
dual – двойной доступ к памяти
HI (LO)– старшие (младшие) 16 разрядов аккумулятора pair – регистровая пара
R, rnd – округление, saturate - насыщение
<instruction>.CR (.LR) – принудительная циклическая (линейная) адресация

21. Кодирование команд
первые 4 бита говорят о коде команды, дальше 4 назначение и 7 смем (методы адресации)

22. Вычисление адресов

\subsection{Устройство управления (08)}
выбирает команды, которые нужно выполнять и организует как параллельное так и конвейерное исполнение. не имеет никакого отношения к шинам данных и адреса. извлекает команды из буфера команд. то есть выполняется кэширование команд (не из основной памяти, а из буфера). считывая код из буфера управляет остальными устройствами. также может передавать данные в устройства адресации и операционное, реализуется распределённая регистровая память.

3. состоит из регистрового файла. можем читать 32разрядные данные. есть логика, которая может осуществлять переходы и генератор адреса. позволяет вызывать из двух команд одну.

4. регистровый файл
\begin{itemize}
\item Хранение промежуточных данных P модуля
\item Двухсторонний обмен данными с генератором
\item Обмен промежуточными данными с модулями A, D и памятью
\end{itemize}

5. внутри файла есть регистры
\begin{itemize}
\item Регистры потока команд:
  \begin{itemize}
  \item PC – Program Counter (счетчик команд); 
  \item RETA – RETurn Address (адреса возврата); 
  \item CFCT – Control Flow ConText (контекст потока управления).
  \end{itemize}
\item Регистры статуса: ST0 - ST3 – Status (состояние микропроцессора).
\item Регистры повторения команды: (сколько раз надо повторить текущую команду)
  \begin{itemize}
  \item RPTC – RePeaT Counter (счетчик повторения); 
  \item CSR – Computed Single-Repeat (число повторений).
  \end{itemize}
\item Регистры повторения блока: (аппаратурно реализуется цикл исполнения команд)
  \begin{itemize}
  \item BRC0, BRC1 – Block-Repeat Counter (счетчик повторения блока команд);
  \item BRS1 – Block-Repeat Save (сохранение BRC1); 
  \item RSA0, RSA1 – Repeat Start Address (начальный адрес блока команд);
  \item REA0, REA1 – Repeat End Address (конечный адрес блока команд).
  \end{itemize}
\item Регистры прерываний:
  \begin{itemize}
  \item IVPD, IVPH – Interrupt Vector Page D, H (страницы векторов прерываний);
  \item IFR0, IFR1 – Interrupt Flag Register (флаги прерываний);
  \item IER0, IER1 – Interrupt Enable Register (разрешения прерываний);
  \item DBIER0, DBIER1 – Debug Interrupt Enable Register.
  \end{itemize}
\end{itemize}

6. Регистр потока команд нужен чтобы запомнить текущее состояние блока повторений. 
CFCT – Control Flow Context (контекст потока управления):
– A – Active (активность повторения текущей команды);
– C – Condition (состояние условия повторения текущей команды);
– S – Status (состояния двух уровней блочного повторения команд): активности, локальность (блок помещен в очередь команд или нет).
на примере указано как его читать и писать.

7. Регистры простого повторения
имеются две команды, которые вычисляют значение цифрового фильтра. для умножения с аккумулированием. обращается к памяти, выполняет умн-слож и меняет адреса операндов для следующего чтения. по всем компонентам выходного вектора тоже нужен цикл. например, (на слайде слева). Е - это флаг параллельности. VLIW архитектура и параллельность на этапе компиляции.

8. регистры блочного повторения
повторяется последовательность команд со вложенностью 2. в регистр загружаем константу кол-во повторений-1, потому что проверяется после тела. получается, что для оргагизации цикла нужна всего одна команда. в брц0 внешний блок в брц1 внутренний внутри брс - сохраняем текущее. в регистрах сохранения сохраняем откуда пришли и куда возвращаться.

9. Регистры страниц прерываний
ISRx – Interrupt Service Routine x (двойное слово с адресом процедуры обработки прерывания и конфигурацией стека).
есть два вектора прерываний, то есть две таблицы адресов прерываний. для системных и пользовательских прерываний. если указать одинаковые адреса таблицы совместятся, но для того чтобы не было коллизий у них не пересекаются векторы.

10. регистры прерываний
есть регистры флагов и разрешения прерываний. есть также регистры аппаратурной отладки. некоторые прерывания можно отлаживать, а некоторые нет.
INT2-INT23 – Interrupt 2-23 (флаги прерываний 2-23).
RTOSINTF – Real Time Operation System Interrupt Flag (флаг прерывания операционной системы реального времени).
DLOGINTF – Data log Interrupt Flag (флаг прерывания протоколирования данных).
BERRINTF – Bus Error Interrupt Flag (флаги прерывания по ошибке обмена по шинам и магистралям).
DBIERx – Debug Interrupt Enable Register (регистры аппаратурной отладки, флаги указывают, какие прерывания вызывают переход в отладочный режим)

11. Конфигурация стеков
есть две конфигурации - для медленного вызова и возврата функций и для быстрого вызова. чтобы это регулировать используются разные коды ЦА и ДА. есть возможность задавать для того процесса, который будет запускаться прерываний свою конфигураци. если используется медленный вызов - это похоже на обычные процессоры. при быстром вызове и возврате извлекается из стека счётчик команд. используется регистр контекста повторения для сохранения адреса возврата. перед записью новых данных нужно сохранять существующие на стеке. чтение и запись выполняется параллельно. инициируем процесс чтения и одновременно параллельно записывается старшая часть регистра и контекста. Пока получаем следующую команду первая уже запишется. при возврате происходит обратный процесс, регистры заполняются из стека. на слайде ошибка стек должен при завершении увеличиваться.

12. в зависимости от текущих условий можем вызывать подпрограмму или нет, которая находится по относительному адресу в регистрах. возврат также бывает по условию.

Соглашения о вызове
\begin{itemize}
\item сdecl - аргументы передаются через стек справа налево, очистку стека производит вызывающая функция. позволяет ellipsis-notation
\item stdcall - аргументы передаются через стек справа налево, очистку стека производит вызываемая функция.
\item pascal - аргументы передаются через стек слева направо, очистку стека производит вызываемая функция.
\item fastcall - аргументы передаются через регистры и через стек. если не помещаются только в регистры.
\item r = fun(a1, a2, a3, ...);
\end{itemize}

Передача аргументов
\begin{itemize}
\item Аргументы функции передаются через стек или через регистры в следующем порядке:
  \begin{itemize}
  \item указатели - (X)AR0, (X)AR1, ..., (X)AR4;
  \item данные 16 бит - T0, T1, AR0, ..., AR4;
  \item данные 32 или 40 бит - AC0, AC1, AC2;
  \item аргумент перед многоточием – в стеке.
  \end{itemize}
\item Структуры более 32 бита передаются через указатель.
\item Аргументы в стеке размещаются в порядке, обратном вызову: *SP(0) – адрес возврата, *SP(1) - 1-й аргумент, ...
\end{itemize}

15. Возврат результата
\begin{itemize}
\item Данные 16 бит – в T0.
\item Данные 32 или 40бит – в AC0.
\item Указатель (24) 16 бит – в (X)AR0.
\item Структура более 32 бита – в первом аргументе – указатель на структуру, если он 0x0, то структура не возвращается.
\end{itemize}
\begin{verbatim}
struct x func(char, int*, long, long long, int, ...)
\end{verbatim}
поскольку данные на стеке выравниваются по два слова, смещение на чётное число.

Сохранение регистров
\begin{itemize}
\item Вызываемая функция:
  \begin{itemize}
  \item должна сохранять и восстанавливать T2, T3, AR5-AR7 при использовании;
  \item может использовать T0, T1 , AR0, AR1, ..., AR4, AC0, AC1, ..., AC3 без сохранения.
  \end{itemize}
\item Вызывающая функция должна сохранять перед вызовом используемые ей регистры T0, T1, AR0, AR1, ..., AR4, AC0, AC1, ..., AC3.
\item При использовании сохраняются регистры RETA, BKx, BRCx, BRS1, BSAx, RSAx, REAx, RPTC, CSR, TRNx, (X)DP, (X)CDP, STx\_55.
\end{itemize}
17. Локальные переменные
• При установленном флаге CPL в ST1 доступ к данным осуществляется через SP, в противном случае – через DP.
• Выделение (освобождение) локальной
памяти: ASUB \#n, SP (AADD \#n, SP).

\subsection{Буфер команд (09)}
(02, 03)
представляет собой 128байтный сдвиговый регистр. все команды поступают на дешифратор и соответствующие данные поступают в P- A- D-модули. У некоторых моделей также есть кэш память команд для ускорения повторного обращения.

(04) для управления кэш-памятью есть специальные биты в регистре статуса. флаг замораживания позволяет задержать данные в кэше. П-модуль выдаёт адреса для чтения текущей команды и данные должны поступить в И-юнит. К-контроллер изначально просто транслирует эти данные в буфер команд по магистрали. помимо этого данные пишутся в К-память (где хранятся как данные, так и адрес). Если П-юнит снова запросит данные, сначала проверяем кэш.

(05) кэш память прямого отображения. все данные разбиваются на три части тэг, набор и смещение по адресу. у нас 2 бита сдвига поэтому блоки будут по 4 байта. сет - это 512 возможных значений. так как в одном месте хранятся разные теги их надо различать (12 разрядов). адрес вызывает коммутацию на компаратор тэга. если тег совпал с тем, которых хранится в этом месте - получаем кэш хит. если хит - данные поступают на магистраль для очереди команд. если промах - ждём несколько тактов пока не поступят данные со внешней памяти. узкое место это использование одной памяти для разных тегов. то есть если у нас будут разные теги каждый раз - всегда будет необходимость брать новые данные и кэширование сведётся к нулю.

(06) ассоциативная КП. является развитием КП с ПО. появилась из-за того что мы хотим расширить объём кэша с одним тэгом. имеем 4 КППО. получается может быть несколько данных с одним и тем же тегом. то есть имеем устройство сравнения тегов.
\begin{itemize}
\item С5501, C5502 – ассоциативная кэш-память с двумя наборами
\item С5510 – режим ассоциативной кэш-памяти с двумя наборами и режим кэш-памяти с прямым отображением
\end{itemize}

(07) Очередь команд
есть кэш или нет - происходит наполнение очереди команд. максимальная длина команды 6 байт. магистраль 4, поэтому команда может не поместиться и будем читать её в два захода. для этого и нужна очередь.

Загрузка 32-битных слов в конец очереди.
\begin{itemize}
\item Сдвиг команд в буфере к началу очереди. очередь загружает по 32бита последовательно сдвигая предыдущие данные. 
\item Передача первых 6 байт в декодер команд. каждые полученные 6 байт являются командой.
\item Хранение локальных блоков повторения (до 128 байт). Если в 128 байтах нет вызовов процедур то они не будут вытеснены из кэша. 
\item Очистка буфера при ветвлениях в программе (переходы, вызов и возврат подпрограмм, прерывания)
\end{itemize}

(09) Декодер команд
\begin{itemize}
\item Получение 6 байт кода для декодирования команды и определения ее размера.
\item Передача команд другим устройствам.
\item Выявление и декодирование команд, которые могут выполнятся параллельно.
\item Передача устройствам непосредственных данных.
\item Передача длины команды для сдвига очереди команд.
\end{itemize}

(10) Чтобы ускорить выполнение применяется конвейеризация.
(11) у конвейера выборки есть 4 стадии
\begin{itemize}
\item PF1 – Prefetch 1 (выдача адреса на шину PAB)
\item PF2 – Prefetch 2 (ожидание устройства памяти) целый такт
\item F – Fetch (получение данных и запись в очередь)
\item PD – Predecode (предварительное декодирование команды в очереди: определение начала и окончания, обнаружение параллельности)
\end{itemize}
чем-то напоминает суперскалярные архитектуры, например х86.

(12) понятно, что параллельно будут несколько операций загрузки, но на разных стадиях. если мы изменяем последовательность команд конвейер очищается и по новому адресу загружается новая последовательность команд с 1й стадии

(13) конвейер выполниения содержит 8 стадий
• D – Decode (декодирование команды)
• AD – Address (вычисление адреса)
• AC1 – Access 1 (доступ 1)
• AC2 – Access 2 (доступ 2)
• R – Read (чтение)
• X – Execute (выполнение)
• W – Write (запись в регистры)
• W+ – Write (запись в память)

если операнд в регистре то ас1 ас2 не нужны и будут холостые такты. третья стадия записи совпадает с декодированием для следующей команды

(14) Декодирование команды (D)
 Чтение 6 байт из буфера команд
• Декодирование одной или двух команд
• Передача команд устройствам
• Чтение режимов адресации:
CPL – режима адресации компилятора; ARMS – режим косвенной адресации; ARxLC, CDPLC – циклическая адресация.

(15) Вычисление адреса(AD)
Чтение регистров, используемых для адресации операндов
• Вычисление адреса операнда – выполнение операции ALU устройства адресации
• Выполнение префиксной операции адресации – модификация регистров
• Вычисление условий ветвления и перезагрузка конвейера при ветвлении, вызове подпрограммы, прерывании)

(16) доступ ас1 и ас2
• AC1 – передача адреса операнда на соответствующую шину адреса (BAB, CAB, DAB)
• AC2 – ожидание данных из памяти один такт

(17) чтение (сигнальный процессор умеет в аппаратные условные операции, которые выполняются как раз на этой стадии).
• Считывание данных из памяти или отображаемых в память регистров (магистрали данных BB, CB, DB)
• Чтение регистров устройства адресации, участвующих в операции обработки данных
• Вычисление условий для условных операций обработки данных

(18) Выполнение
• Чтение и модификация регистров, участвующих в операции, кроме регистров, отображаемых в память (изменение регистров операционного устройства)
• Чтение и модификация отдельных бит (устройство битовых операций DB\_BIT)
• Установка условий по результату операции обработки данных

(19) Запись результата
• W – Запись данных в регистры, отображаемые в память, регистры периферийных устройств или начало записи данных в ячейку памяти
• W+ – Завершение записи данных в ячейку памяти

(20) так как параллельность из 8 этапов - каждая команда будет выполняться примерно один такт. каждое ветвление это перезагружка конвейера, то есть теряется 8 тактов.

(21) почему возникает перезагрузка
• Команды условных переходов ВСС
• Команда безусловного перехода B
• Команда вызова подпрограммы CALL
• Программное прерывание INTR
• Внешние прерывания по сигналу INT0, INT1
• Внутренние немаскируемые прерывания по сигналу NMI
• Сброс процессора по сигналу RESET или командой программного сброса RESET

(22) Конфликты записи до чтения
конфликт - это когда две соседние команды не могут выполняться подряд из-за зависимости результатов предыдущих команд. способа кроме добавления холостых циклов нет

уязвимость Meltdown

(23) Конфликты доступа
При параллельном выполнении команд забота о предотвращении конфликтов в конвейере ложится на компилятор (на программиста)

(24) параллельное выполнение нескольких команд
независимые устройства - каждый юнит из изученных.

(25) виды параллелизма
• Встроенный (нет бита параллельности E) MPY *AR0, *CDP, AC0 ; 1-й умножитель :: MPY *AR1, *CDP, AC1 ; 2-й умножитель
это команды со сверхдлинным командным словом. это сцепленные между собой команды. 

• Пользовательский (бит E во 2-ой команде) ADD AC0, AC1 ; AЛУ D-блока
|| XOR AR2, CDP ; AЛУ A-блока, E=1
можем использовать две команды для выполнения операции. компилятор добавляет специальный бит XOR и используем АЛУ блока адресации

• Комбинированный (бит E в 3-ей команде) MPY *AR3+, *CDP+, AC0 ; 1-й умножитель :: MPY *AR4+, *CDP+, AC1 ; 2-й умножитель || MOV \#5, AR1 ; РФ А-блока, E=1
засылает команду в регистровый файл и тогда одновременно выполняется три команды.

• Двойной доступ (доступ к памяти, нет E) MOV *AR-, AC1 ; CAB/BB, DAB/DB MOV *CDP+, AC2 ; BAB/BB


\newpage
\subsection{Обработка прерываний (10)}
\textbf{Прерывание (Interrupt)} – переключение микропроцессора на выполнение программ обработки асинхронно возникающих внутренних или внешних событий. Прерывание может иметь как внешние, так и внутренние причины. Чтобы программа могла нормально выйти из обработки прерывания и восстановить работ, нужно сохранить текущий контекст, а затем его восстановить, это часть времени реакции на прерывание. 

\subsubsection{Источники прерываний}
\begin{itemize}
\item Источники прерываний: – немаск\'{и}руемые:
  \begin{enumerate}
  \item внутреннее – от схем контроля \code{NMI};
  \item сброс по входу \code{RESET};
  \end{enumerate}
\item маск\'{и}руемые:
  \begin{enumerate}
  \item внешние – по входу \code{INT0}, \code{INT1};
  \item аппаратурные – от модулей;
  \end{enumerate}
\item программные – по командам \verb|INTR #k4|, \verb|TRAP #k4|. Фактически входят в состав маск\'{и}руемых
\end{itemize}
(04)

\subsubsection{Последовательность прерывания}
\begin{enumerate}
\item Аппаратурные средства
  \begin{enumerate}
  \item Контроллер устройства генерирует запрос на прерывание
  \item Процессор прекращает исполнение текущей программы
  \item Процессор сигнализирует о получении прерывания и считывает вектор прерывания
  \item Процессор заносит слово состояния и программный счётчик в стек
  \item в программный счётчик загружается новое значение, пределяемое прерыванием
  \end{enumerate}
\item Программные средства
  \begin{enumerate}
  \item Сохранение данных состояния процессора
  \item Обработка прерывания
  \item Восстановление данных состояния процессора
  \item Восстановление старого слова состояния программы и содержимого программного счётчика
  \end{enumerate}
\end{enumerate}

(6)
5000-стек50001-вектор0004-6000-обработчик6000-6100-RETI-стекST-5001

\textbf{Вложенные прерывания}
(7)
как правило нет систем без глубины вложенности прерываний и без приоритетов прерываний.

\subsubsection{Вектор прерываний}
\begin{table}[h!]
  \centering
  \begin{tabular}{r|lr|} 
    \cline{2-3}
     & 15 & 0 \\ [0.5ex] 
    \cline{2-3}
    IVPD & 00 0049h & Страница векторов 0-15, 24-31 \\ 
    IVPH & 00 004Ah & Страница векторов 16-23 \\
    \cline{2-3}
  \end{tabular}
\end{table}
Обе эти таблицы могут обрабатывать 32 прерывания. разнесены для организации отдельно обработки пользовательских Human и ОС Device прерываний.
\begin{table}[h!]
  \centering
  \begin{tabular}{r|r|r} 
    Вектор & \textbf{IVPD}|00h & Байт \\ [0.5ex] 
    \cline{2-2}
    (8)
  \end{tabular}
\end{table}

Процедура прерываний
(9)
ISR – Interrupt Service Routine (процедура обработки прерывания).
SC – Stack Configuration (байт конфигурации стека, игнорируется для всех векторов, кроме RESET): CAh – быстрый вызов-возврат и два независимых 16- разрядных стека; DAh – медленный вызов-возврат и два независимых 16- разрядных стека; EAh – медленный вызов-возврат и единый 32-разрядный стек.
EP – Entry Point (точка входа, или 24-разрядный адрес процедуры).

Чтобы разрешить или зарпетить маскируемые прерывания выставляем 11й бит в регистре ST1\_55. В этом регистре мы можем также задавать разные режимы работы прерываний.

\subsubsection{Конфигурация стеков}
Медленный вызов и возврат \code{NO_RETA} (ISR DAXX:XXXXh) регистр возврата не используется
Быстрый вызов и возврат \code{USE_RETA} (ISR CAXX:XXXXh) регистр возврата используется
(10)
\begin{itemize}
\item \textbf{CALL}: [PC, Контекст повторения]$\to$[RETA, CFCT] :: [RETA, CFCT]$\to$[*-SP, *-SSP]
\item \textbf{RET}: [RETA, CFCT]$\to$[PC, Контекст повторения] :: [*SP-, *SSP-]$\to$[RETA, CFCT]
\end{itemize}

\subsubsection{Регистры и источники  прерываний}
(11)
\begin{itemize}
\item [] \textbf{INT2-INT23} – Interrupt 2-23 (флаги прерываний 2-23).
\item [] \textbf{RTOSINTF} – Real Time Operation System Interrupt Flag (флаг прерывания операционной системы реального времени).
\item [] \textbf{DLOGINTF} – Data log Interrupt Flag (флаг прерывания протоколирования данных).
\item [] \textbf{BERRINTF} – Bus Error Interrupt Flag (флаги прерывания по ошибке обмена по шинам и магистралям).
\item [] \textbf{DBIERx} – Debug Interrupt Enable Register (регистры аппаратурной отладки, флаги указывают, какие прерывания вызывают переход в отладочный режим)
\end{itemize}

\begin{table}[H]
  \centering
  \begin{tabular}{|c|c|c|c|} 
    \hline
    Вектор & Адрес & Приор. & Обозначение и источник прерывания \\ [0.5ex] 
    \hline
    ISR00 & IVPD:00h & 1 & RESET, по сбросу и инициализации \\
    ISR01 & IVPD:08h & 3 & NMI, от схем контроля (внутреннее немаскируемое)\\
    ISR02 & IVPD:10h & 5 & INT0, внешнее прерывание по входу INT0 \\
    ISR03 & IVPD:18h & 7 & INT1, внешнее прерывание по входу INT1 \\
    ISR04 & IVPD:20h & 8 & TINT, агрегированное прерывание от таймеров \\
    ISR05 & IVPD:28h & 9 & PROG0, от контроллера I2S0 и MMC/SD0 по передаче \\
    ISR06 & IVPD:30h & 11 & UART, от приемо-передатчика UART \\
    ISR07 & IVPD:38h & 12 & PROG1, от контроллера I2S0 и MMC/SD0 по приему \\
    ISR08 & IVPD:40h & 13 & DMA, от канала прямого доступа к памяти \\
    ISR09 & IVPD:48h & 15 & PROG2, от контроллера I2S1 и MMC/SD1 по передаче \\
    ISR10 & IVPD:50h & 16 & FFT, от аппаратного ускорителя БПФ \\
    ISR11 & IVPD:58h & 17 & PROG3, от контроллера I2S1 и MMC/SD1 по приему \\
    ISR12 & IVPD:60h & 19 & LCD, от контроллера дисплея \\
    ISR13 & IVPD:68h & 20 & SAR, агрегированное от АЦП \\
    ISR14 & IVPD:70h & 23 & XTM2, от контроллера I2S2 по передаче \\
    ISR15 & IVPD:78h & 24 & RCV2, от контроллера I2S2 по приему \\
    \hline
  \end{tabular}
  \caption{Источники прерываний IVPD.}
\end{table}

\begin{table}[H]
  \centering
  \begin{tabular}{|c|c|c|c|} 
    \hline
    Вектор & Адрес & Приор. & Обозначение и источник прерывания \\ [0.5ex] 
    \hline
    ISR16 & IVPH:80h & 6 & XMT3, от контроллера I2S3 по передаче \\
    ISR17 & IVPH:88h & 10 & RCV3, от контроллера I2S3 по приему \\
    ISR18 & IVPH:90h & 14 & RTC, от часов реального времени \\
    ISR19 & IVPH:98h & 18 & SPI, от контроллера SPI \\
    ISR20 & IVPH:A0h & 21 & USB, от контроллера USB \\
    ISR21 & IVPH:A8h & 22 & GPIO, от портов ввода-вывода общего назначения \\
    ISR22 & IVPH:B0h & 23 & EMIF, от интерфейса внешней памяти при ошибках \\
    ISR23 & IVPH:B8h & 26 & I2C, от контроллера I2C \\
    ISR24 & IVPD:C0h & 4 & BERR, при ошибке обмена по шинам и магистралям \\
    ISR25 & IVPD:C8h & 27 & DLOG, протоколирование данных (программное) \\
    ISR26 & IVPD:D0h & 28 & RTOS, вызов операционной системы (программное) \\
    ISR27 & IVPD:D8h & – & RTDRCV, от эмулятора по приему \\
    ISR28 & IVPD:E0h & – & RTDXMT, от эмулятора по передаче \\
    ISR29 & IVPD:E8h & 2 & EMUINT, от монитора эмулятора \\
    ISR30 & IVPD:F0h & – & SINT30, пользовательское (программное) \\
    ISR31 & IVPD:F8h & – & SINT31, пользовательское (программное) \\
    \hline
  \end{tabular}
  \caption{Источники прерываний IVPD.}
\end{table}

\subsubsection{Секция vectors}
\begin{lstlisting}[style=ASMStyle]
 .sect "vectors"
 .ref _c_int00, _nmi_isr, _sarISR, _int0_isr, _int1_isr, _tim_isr
 .ref _i2s0_mmc0_tx_isr, _uart_isr, _i2s0_mmc0_rx_isr, _dma_isr .ref _i2s1_mmc1_tx_isr, _coprocfft_isr, ..., _sint31_isr
 .def _VECSTART, _no_isr
_VECSTART:                      ; USE_RETA, NO_RETA, C54X_STK
RST: .ivec   _c_int00, USE_RETA ; 00 Reset / Software Interrupt #0
NMI: .ivec   _nmi_isr           ; 01 Nonmaskable Interrupt
INT0: .ivec  _int0_isr          ; 02 External User Interrupt #0
INT1: .ivec  _int1_isr          ; 03 External User Interrupt #1
TINT: .ivec  _tim_isr           ; 04 Timer #0 / Software Interrupt #4
PROG0: .ivec _i2s0_mmc0_tx_isr  ; 05 Programmable 0 Interrupt
UART: .ivec  _uart_isr          ; 06 IIS #1 Receive Interrupt
PROG1: .ivec _i2s0_mmc0_rx_isr  ; 07 Programmable 1 Interrupt
DMA: .ivec   _dma_isr           ; 08 DMA Interrupt
PROG2: .ivec _i2s1_mmc1_tx_isr  ; 09 Programmable 2 Interrupt
FFT: .ivec   _coprocfft_isr     ; 10 Coprocessor FFT Module Interrupt
PROG3: .ivec _i2s1_mmc1_rx_isr  ; 11 Programmable 3 Interrupt
LCD: .ivec   _lcd_isr           ; 12 LCD Interrupt
SAR: .ivec   _saradc_isr        ; 13 SAR ADC Interrupt
XMT2: .ivec  _i2s2_tx_isr       ; 14 I2S2 Tx Interrupt
RCV2: .ivec  _i2s2_rx_isr       ; 15 I2S2 Rx Interrupt
XMT3: .ivec    _i2s3_tx_isr     ; 16 I2S3 Tx Interrupt                  
RCV3: .ivec    _i2s3_rx_isr     ; 17 I2S3 Rx Interrupt                  
RTC: .ivec     _rtc_isr         ; 18 RTC interrupt                      
SPI: .ivec     _spi_isr         ; 19 SPI Receive Interrupt              
USB: .ivec     _usb_isr         ; 20 USB Transmit Interrupt             
GPIO: .ivec    _gpio_isr        ; 21 GPIO Interrupt                     
EMIF: .ivec    _emif_error_isr  ; 22 EMIF Error Interrupt               
I2C: .ivec     _i2c_isr         ; 23 IIC interrupt                      
BERR: .ivec    _berr_isr        ; 24 Bus Error Interrupt                
DLOG: .ivec    _dlog_isr        ; 25 Emulation Interrupt - DLOG         
RTOS: .ivec    _rtos_isr        ; 26 Emulation Interrupt - RTOS         
RTDRCV: .ivec  _rtdxrcv_isr     ; 27 Emulation Interrupt - RTDX receive 
RTDXMT: .ivec  _rtdxxmt_isr     ; 28 Emulation Interrupt - RTDX transmit
EMUINT: .ivec  _emuint_isr      ; 29 Emulation monitor mode interrupt   
SINT30: .ivec  _no_isr          ; 30 Software Interrupt #30             
SINT31: .ivec  _sint31_isr      ; 31 Software Interrupt #31             
 .text                   
_no_isr: nop
label: jmp     label
\end{lstlisting}

\begin{lstlisting}[language=C,style=CCodeStyle, caption={Описание регистров}]
#define Uint16 unsigned int
typedef struct {
  volatile Uint16 IER0;     /*0000h – <@\lh{dkgreen}{разрешения прерываний}@> 0 */ 
  volatile Uint16 IFR0;     /*0001h – <@\lh{dkgreen}{флаги прерываний}@> 0 */      
  volatile Uint16 ST0_55;   /*0002h – <@\lh{dkgreen}{состояние процессора}@> 0 */  
  volatile Uint16 ST1_55;   /*0003h – <@\lh{dkgreen}{состояние процессора}@> 1 */  
  volatile Uint16 ST3_55;   /*0004h – <@\lh{dkgreen}{состояние процессора}@> 3 */  
  volatile Uint16 Res0[64]; /*0008h – <@\lh{dkgreen}{регистры микропроцессора}@> */
  volatile Uint16 IER1;     /*0045h – <@\lh{dkgreen}{разрешения прерываний}@> 1 */ 
  volatile Uint16 IFR1;     /*0046h – <@\lh{dkgreen}{флаги прерываний}@> 1 */      
  volatile Uint16 DBIER0;   /*0047h – <@\lh{dkgreen}{разрешения отладки}@> 0 */    
  volatile Uint16 DBIER1;   /*0048h – <@\lh{dkgreen}{разрешения отладки}@> 1 */    
  volatile Uint16 IVPD;     /*0049h – <@\lh{dkgreen}{таблица прерываний}@> D */    
  volatile Uint16 IVPH;     /*004Ah – <@\lh{dkgreen}{таблица прерываний}@> H */    
  volatile Uint16 ST2_55;   /*004Bh – <@\lh{dkgreen}{состояние процессора}@> 2 */  
  volatile Uint16 Res1[4];  /*004Ch – <@\lh{dkgreen}{регистры микропроцессора}@> */
} INT_Registers;

#define INT_REGS ((INT_Registers*)0x0000)

INT_REGS->IVPD = (Uint16)(VECTSTART >> 8);
INT_REGS->IVPH = INT_REGS->IVPD;
\end{lstlisting}

(17-18-19)
\begin{lstlisting}[language=C,style=CCodeStyle, caption={Установка вектора (C)}]
  typedef void (*isr)(void);
  isr ISR_plug(int num, isr iep) {
    unsigned long old, *ivp;
    unsigned int *reg;
    reg = (unsigned int*)(num >= 16 && num <= 23 ? 0x49 : 0x4A);
    ivp = (unsigned long*)(*reg << 3 + num << 2);
    asm(" BSET INTM");
    
    asm(" BCLR INTM");
  }
\end{lstlisting}

\section{Прямой доступ к памяти}
(11-06) В домашке 3 входные данные могут поступать на плату или с микрофона или с кабеля. Необходимо осуществить двойную буферизацию и конвейер.
\begin{frm}
  getSample
  заполнить буфер
  обработать буфер
  putSample
\end{frm}

В реальных системах такая обработка делается не через прерывания, а через систему прямого доступа к памяти. У современных систем 16 каналов для обработки. Из них слышимые канальные данные 12+1.
Если используем прерывания то данные идут через CPU, если нет, то напрямую.
RAM – Random Access Memory (память с произвольным доступом).
CPU – Central Processor Unit (центральный процессор).
DMA – Direct Memory Access (прямой доступ к памяти).
PIO – Programmable Input-Output (программный ввод-вывод данных).

(11-03) Прямой доступ к памяти
У всех микропроцессоров есть канал DMA. В случае ЕМИФ МП получает доступ к общей внешней памяти многопроцессорной системы. HPI - специальный тип доступа ко внутренней памяти кристалла. у интел это называется non-uniform memory access. у арма есть аналог.
Direct Memory Access (прямой доступ к памяти) – режим обмена данными между микропроцессорами, устройствами микропроцессора или же между устройством и основной памятью, в котором центральный процессор не участвует:
• Direct memory access (DMA) – доступ устройств к основной памяти;
• Extended memory interface (EMIF) – доступ микропроцессора к внешней и общей памяти мультипроцессорной системы;
• Host port interface (HPI) – доступ микропроцессора к основной памяти другого микропроцессора.

(11-04) Канал прямого доступа
Канал прямого доступа получает доступ через внутреннюю шину. арбитр регламентирует доступ к шине. Обычно это два такта, но можно сделать и за один при этом канал выдаёт устройству сигнал чтения, а основной памяти сигнал записи. 
DRQ – DMA Request (запрос прямого доступа к памяти).
DACK – DMA Acknowledge (предоставление прямого доступа).
A (D) – Address (Data) Bus (шина адреса и магистраль данных).
R (W) – Read (Write) command (сигналы чтения и записи).

(11-05) в нашем МП есть 4 контроллера по 4 канала прямого доступа к памяти. всего 16 каналов, помимо регистров для настройки чтения и записи имеется ещё и буфер, в зависимости от готовности устройств можем читать быстрее, чем записали. Внутри такой буфер устроен как очередь. Переключение буферов происходит как в домашке. Чем меньше размер буфера, тем больше накладные расходы, но чем больше буфер, тем дольше сама обработка. 

Интерфейс внешней и внутренней памяти.
Канал прямого доступа считывает данные из одного контроллера (из одного сегмента) и записывает, например, в память двойного доступа. После чего переходит в режим ожидания. Важно, что адресация данных и адресация устройств - разная. 

% (11-09) Интерфейс памяти EMIF
% EM_WE – Write enable; EM_BA[1:0] – Bank Address; EM_A[20:0] – Address bus; EM_D[15:0] – Data bus; EM_DQM[1:0] – Byte enables;
% EM_SDCKE – Clock Enable; EM_SDCLK – Clock;
% EM_CS[1:0] – Chip Select; EM_SDRAS – Row Address Strobe; EM_SDCAS – Column Address Strobe;
% EM_CS[5:2] – Chip Select; EM_OE – Output Enable; EM_RW – Read/Write; EM_WAIT[3:0] – Wait signals;

У емиф есть некоторый центральный контроллер, который подключается к процессору, память, юсб, дисплей. Пассивными устройствами внутренней памяти являются САРАМ и ДАРАМ. можем читать из внутренней памяти. Устройство имеет регистры, чтобы можно было регулировать интерфейс внешней памяти. Возможно подключить два типа внешней памяти синхронную и асинхронную. Есть общие линии для обоих этих интерфейсов. При асинхронном обмене есть обратная связь от внешней памяти поскольку память работает медленнее микропроцессора.

Схемы включения: (11-19)(11-22)(11-29)
в асинк есть сигнал ожидания
в общей есть сигналы синхронизации

(11-10) Динамическая память
статическая память хранит постоянно, а динамическая максимум 4мсек и поэтому нужно постоянно её обновлять, в МП этим занимается специальный контроллер-регенератор. Любое чтение строки восстанавливает состояние в этой строке. Если чтения не было конденсатор обнуляется. Для получения конкретного бите есть мультиплексор, на который подключен сигнал номера колонок.
RAS – Row Address Strobe (строб адреса строки)
CAS – Column Address Strobe (строб адреса столбца)
RG – Register (регистр с параллельной записью)
CT – Counter (счетчик с параллельной записью)
DC – Decoder (дешифратор, декодер)
MUX – Multiplexor (мультиплексор, коммутатор)

(11-11) Режимы работы ДП.
Страничный - читаем сразу блок, и потом уже читаем из кэша.
пакетный - если номера столбцов меняются последовательно, то зачем их задавать. и так с каждым следующим тактом будет поступать сразу следующий бит данных.

(11-13) таким образом команды RAS CAS BA стали частью кода команд процессора для работы с памятью. 



\section{Взаимодействие микропроцессора со внешними устройствами}
\subsection{Входы-выходы общего назначения(12)}
снизу справа 3 вторичных источника внутреннего  питания (3 LDO), двухканальный ЦАП резистивного экрана (SAR), LCD индикатор 400х200, UART, два $I^2S$ (и ещё два сверху) двунаправленный двухканальный интерфейс, SPI, GPIO. Последовательный интерфейс I2S ни с кем не конкурирует, но для этого остальные интерфейсы (особенно внизу микропроцессора) значительно намешаны. То есть возможно комбинировать SPI, UART, I2C или GPIO, например. Часть выводов для графического дисплея могут забираться от SPI и GPIO. Очевидна проблема, что число выводов недостаточно. Для полного описания таких комбинаций вводят таблицу альтернативных функций.

\begin{table}[h!]
  \centering
  \begin{tabular}{||r|c|c||} 
    \hline
Имя & Вывод & Альтернативная функция\\
GP[0] & L10 & MMC0\_CLK, I2S0\_CLK\\
GP[1] & M11 & MMC0\_CMD, I2S0\_FS\\
GP[2] & L9 & MMC0\_D0, I2S0\_DX \\
GP[3] & M10 & MMC0\_D1, I2S0\_RX \\
GP[4] & L12 & MMC0\_D2 \\
GP[5] & L11 & MMC0\_D3 \\
GP[6] & M13 & MMC1\_CLK, I2S1\_CLK \\
GP[7] & L14 & MMC1\_CMD, I2S1\_FS \\
GP[8] & M14 & MMC1\_D0, I2S1\_DX \\
GP[9] & M12 & MMC1\_D1, I2S1\_RX \\
GP[10] & K14 & MMC1\_D2 \\
GP[11] & L13 & MMC1\_D3 \\
GP[12] & P7 & LCD\_D[2] \\
GP[13] & N7 & LCD\_D[3] \\
GP[14] & N8 & LCD\_D[4] \\
GP[15] & P9 & LCD\_D[5] \\
GP[16] & N9 & LCD\_D[6] \\
GP[17] & P10 & LCD\_D[7] \\
GP[18] & N10 & LCD\_D[8], I2S2\_CLK, SPI\_CLK \\
GP[19] & P11 & LCD\_D[9], I2S2\_FS, SPI\_CS0 \\
GP[20] & N11 & LCD\_D[10], I2S2\_RX, SPI\_RX \\
GP[21] & N1 & EM\_A[15] \\
GP[22] & E2 & EM\_A[16] \\
GP[23] & G1 & EM\_A[17] \\
GP[24] & G2 & EM\_A[18] \\
GP[25] & G4 & EM\_A[19] \\
GP[26] & J3 & EM\_A[20] \\
GP[27] & P12 & LCD\_D[11], I2S2\_DX, SPI\_TX \\
GP[28] & N12 & LCD\_D[12], I2S3\_CLK, UART\_RTS \\
GP[29] & P13 & LCD\_D[13], I2S3\_FS, UART\_RTS \\
GP[30] & N13 & LCD\_D[14], I2S3\_RX, UART\_RXD \\
GP[31] & P14 & LCD\_D[15], I2S3\_DX, UART\_TXD \\
    \hline
  \end{tabular}
\end{table}

Почему возможно подключение нескольких источников к одному входу? каждый вывод подключен через регистр и триггер шмитта, поэтому мы можем осуществлять как аналоговый так и цифровой вывод. аналогично ввод мультиплексируется и подтягивается либо к напряжению питания, либо к земле. Есть коммутатор, позволяющий забирать данные с разных интерфейсов МП. Возможно, отключив стандартную схему контроля использовать вывод как аналоговый (12-04).

Регистр выбора шин находится в адресном пространстве ввода-вывода.
EBSR (1C00h) – External Bus Selection Register (регистр выбора внешних шин)
(12-06)

С помощью этого регистра можем регулировать назначение выводов МП.

PPMODE – Parallel Port Mode (режим параллельного порта, 21 вывод):
\begin{itemize}
\item 000 – LCD[21 вывод];
\item 001 – SPI[7 выводов], GPIO[29:27, 20:18], UART[4 вывода] и I2S2 [4 вывода];
\item 010 – LCD[13 выводов] и GPIO[31:27, 20:18];
\item 011 – LCD[13 выводов], SPI [4 вывода] и I2S3 [4 вывода];
\item 100 – LCD[13 выводов], I2S2 [4 вывода] и UART [4 вывода];
\item 101 – LCD[13 выводов], SPI[4 вывода] и UART[4 вывода];
\item 110 – SPI[7 выводов], I2S2[4 вывода], I2S3[4 вывода] и GPIO[29:27, 20:18];
\item 111 – зарезервировано)
\end{itemize}

SP1MODE – Serial Port 1 Mode (режим последовательного порта 1, 6 выводов:
\begin{itemize}
\item 00 – MMC/SD1[6 выводов]; 
\item 01 – I2S1[4 вывода] and GPIO[11:10];
\item 10 – GPIO[11:6]; 
\item 11 – зарезервировано)
\end{itemize}

SP0MODE – Serial Port 0 Mode (режим последовательного порта 1, 6 выводов: 
\begin{itemize}
\item 00 – MMC/SD0[6 выводов]; 
\item 01 – I2S0[4 вывода], GPIO[5:4];
\item 10 – GPIO[5:0];
\item 11 – зарезервировано)
\end{itemize}

Ax\_MODE – Аx Mode (режим адресных выводов A[20:15]:
\begin{itemize}
\item 0 – интерфейс расширенной памяти, 
\item 1 – входы-выходы общего назначения GPIO[26:21])
\end{itemize}

Подтягивающие регистры
При использовании I2S нельзя работать без подтягивающих регистров, поскольку это выводы с открытым коллектором. Входы могут быть подключены к резисторам, подтягивающим к питанию или земле. Это можно использовать для линий прерываний. Для управления используются соответствующие регистры, в которые необходимо выставить управляющие биты. 

(12-07)

• PU – Pull-Up (подтягивание к питанию)
• PD – Pull-Down (подтягивание к земле)
• S – Serial port (выводы последовательных портов)
• INTx – Interrupt x (выводы прерывания микропроцессора) • RESET – Reset (вывод сброса микропроцессора)
• EMU01 – Emulator (выводы 0 и 1 прерывания эмулятора) • TDI – Test data input (JTAG, вывод входных данных)
• TMS – Test mode select (JTAG, вывод выбора режима)
• TCK – Test clock (JTAG, вывод тактового сигнала)
• A – Address (адресные выводы EMIF)

Регистры входов-выходов. Если мы настроили регистры на использование ГПИО, то можно этими входами-выходами управлять вспомогательными регистрами

\begin{table}[h!]
  \centering
  \begin{tabular}{||r|c|p{10cm}||} 
    \hline
Адрес в памяти & Обозначение & Описание \\
1C06h & IODIR1 & Регистр направления 1 (0 – ввод данных, 1 – вывод данных) \\
1C07h & IODIR2 & Регистр направления 2 (0 – ввод данных, 1 – вывод данных) \\
1C08h & IOINDATA1 & Регистр входных данных 1 (0 – вход “0”, 1 – вход “1”) \\
1C09h & IOINDATA2 & Регистр входных данных 2 (0 – вход “0”, 1 – вход “1”) \\
1C0Ah & IODATAOUT1 & Регистр выходных данных 1 (0 – выход “0”, 1 – выход “1”) \\
1C0Bh & IODATAOUT2 & Регистр выходных данных 2 (0 – выход “0”, 1 – выход “1”) \\
1C0Ch & IOINTEDG1 & Регистр полярности прерываний 1 (0 – передний фронт, 1 – задний) \\
1C0Dh & IOINTEDG2 & Регистр полярности прерываний 2 (0 – передний фронт, 1 – задний) \\
1C0Eh & IOINTEN1 & Регистр разрешения прерываний 1 (0 – запрещено, 1 – разрешено) \\
1C0Fh & IOINTEN2 & Регистр разрешения прерываний 2 (0 – запрещено, 1 – разрешено) \\
1C10h & IOINTFLG1 & Регистр флагов прерываний 1 (0 – нет события, 1 – событие есть) \\
    1C11h & 7IOINTFLG2 &Регистр флагов прерываний 2 (0 – нет события, 1 – событие есть) \\
    \hline
  \end{tabular}
\end{table}

• IO – Input-Output (входы-выходы)
• DIR – Direction (направление)
• IN, OUT – Input, Output (вход, выход)
• INT – Interrupt (прерывание) 15 0 • EDG – Edge (фронт) REG1
• EN – Enable (разрешение) 15 0
• FLG – Flag (флаг)

Вектор прерываний
\begin{table}[h!]
  \centering
  \begin{tabular}{|c|c|c|c||} 
    \hline
Вектор &прерывание &приоритет &адрес\\
00 RESET &сброса и инициализации &00& IVPD:00h\\
04 TINT &агрегирование таймера &06& IVPD:20h\\
08 DMA& Прямого доступа к памяти &11& IVPD:40h\\
13 SAR& Агрегированное АЦП &18& IVPD:68h\\
18 RTC& Часов реального времени &12& IVPH:90h\\
21 GPIO& Портов ввода-вывода &20& IVPH:A8h\\
    \hline
  \end{tabular}
\end{table}

(12-09)
IFR1
00 0046h

IER1
00 0045h

пример программы (12-12,13,14)

\subsection{Приборный интерфейс (13)}
I2C – Inter-Integrated Circuit (межмикросхемный интерфейс) Master – ведущее устройство
Slave – ведомое устройство
SDA – Serial Data (последовательные данные)
SCL – Serial Clock (последовательные тактовые сигналы) GND – Ground (общий проводник)
Vcc – Voltage Common Collector (напряжение питания)

Без программирования I2C не получится запустить никакие периферийные устройства, поскольку интерфейс является связующим звеном между микросхемами.

(13-04). На физическом уровне есть два подтягивающих к питанию резистора управляющих ног SDA и SCL. Применяется для управления любыми периферийными устройствами. любое из устройств может управлять линией данных. Если два устройства установили низкий уровень, то мы не поймём, какое именно.

(13-05,06) Интерфейс может находиться в 4 состояниях
\begin{enumerate}
\item пассивное, когда управляющие на высоком уровне
\item переход к получению данных (падение СДА в низкий уровень). все на шине видят, что появился мастер.
\item смена данных (тактовый сигнал в низком уровне)
\item передача данных
\item смена данных (снова низкий уровень тактового сигнала)
\item отпустить клок (выставиться на высоком уровне) и выставить СДА на высокий, переход в пассивное состояние.
\end{enumerate}
Подтверждение получения данных - получатель отправляет подтверждение, отправив СДА в низкий уровень. при получении подтверждения ведущий или ведомый отправляет данные, в зависимости от режима (читать хочет мастер или писать).

(13-07) для синхронизации быстрых и медленных устройств ведомый удерживает своим клоком быстрые клоки ведущего. Устройство, удерживающее низкий уровень тактового сигнала в линии, перекрывает такое удержание от всех других устройств. Если ведомое устройство удерживает низкий уровень тактового сигнала, остальные устройства переходят в состояние ожидания. Медленные ведомые устройства притормаживают быстрые ведущие устройства на время удержания тактового сигнала, достаточное для приема и сохранения данных (подготовки и передачи данных).

(13-08) два разных мастера могут захотеть отправлять данные. возникает необходимость арбитража. Устройство, передающее данные с меньшим значением имеет больший приоритет на интерфейсе. Если несколько устройств передают похожие данные, то арбитраж наступает тогда, когда данные становятся различными. То есть кто передал не тоже самое, что находится на линии отключается от линии и потеря арбитража.

(13-09) Существует несколько протоколов I2C
\begin{itemize}  
\item формат 7-битной адресации
\item формат 10-битной адресации: для адреса передаются 2 байта, но для совместимости с 7-битным в 7-битной зарезервированы (11110ХХ) значит что адресация 10-битная
\item свободный формат: используется когда один ведущий и один ведомый, всегда можем передавать только данные.
\item формат повторения: захватываем линию, передаём данные, получаем подтверждение, снова передаём старт, а не стоп и продолжаем пока не надоест
\end{itemize}

Режимы работы:
- ведомый приемник (slave-receiver mode);
- ведомый передатчик (slave-transmitter mode);
- ведущий приемник (master-receiver mode);
- ведущий передатчик (master-transmitter mode).

(13-10) контроллер встроен в микропроцессор, поэтому связан с остальным процессором и внутренней шиной данных. у контроллера всегда есть своя тактовая частота и прескалер чтобы формировать синхросигнал тактов. арбитр определяет арбитраж. учитывая, что интерфейс последовательный, имеется сдвиговый регистр, регистр передатчика и приёмника. приёмник и передатчик работают идентично, кто именно будет работать определяет арбитр.

(13-11) в нормальном состоянии все устройства всегда отключены. Для включения контроллера необходимо осуществить формирование тактового питания контроллера. То есть записать в 6й бит регистра PCGCR1 (1C02h) – Peripheral Clock Gating Configuration Register 1. Это сформирует разрешение использование внешнего или внутреннего тактового сигнала.
\[ f_{SCL} = \frac{f_{ICPSC}}{(N_{ICCLKH} + d)(N_{ICCLKL} + d)}, d \in \{7,6,5\} \]

Прескалер отличается от делителя тем, что не важно какая частота на входе, можно делением или умножением получить любую другую. Далее регистр делителя формирует интерфейсную.

Вектор прерываний по счёту 23 Контроллера I2C приоритет 24 IVPH:B8h (8 байт команды перехода и 4 байта команды NOP).

Для управления существует много регистров
\begin{table}[h!]
  \centering
  \begin{tabular}{|c|c|c|} 
    \hline
Адрес & Обозначение &Описание\\
    \hline
1A00h & ICOAR & Own Address Register (регистр собственных адресов)\\
    \hline
1A04h & ICIMR & Interrupt Mask Register (регистр маски прерываний )\\
    \hline
1A08h & ICSTR & Interrupt Status Register (регистр статуса прерываний )\\
    \hline
1A0Сh & ICCLKL&  Clock Low-Time Divider Register (регистр делителя частоты )\\
    \hline
1A10h & ICCLKH&  Clock High-Time Divider Register (регистр делителя частоты )\\
    \hline
1A14h & ICCNT & Data Count (счетчик данных)\\
    \hline
1A18h & ICDRR & Data Receive Register (регистр принятых данных )\\
    \hline
1A1Ch & ICSAR & Slave Address Register (регистр подчиненного адреса )\\
    \hline
1A20h & ICDXR & Data Transmit Register (регистр передаваемых данных )\\
    \hline
1A24h & ICMDR & Mode Register(регистр режима )\\
    \hline
1A28h & ICIVR & Interrupt Vector Register (регистр вектора прерываний )\\
    \hline
1A2Ch & ICEMDR&  Extended Mode Register (регистр расширенного режима )\\
    \hline
1A30h & ICPSC & Prescaler Register (регистр прескалера )\\
    \hline
1A34h & ICPID1&  Peripheral Identification Register 1 (регистр идентификации 1)\\
    \hline
1A38h & CPID2 & Peripheral Identification Register 2 (регистр идентификации 2)\\
    \hline
  \end{tabular}
  \caption{Регистры $I^2C$}
  \label{table:regs-i2c}
\end{table}

(13-14) Регистры адреса и масок
(13-15) Регистр статуса
(13-16) Регистры приема-передачи
(13-17) Регистр режима
(13-19) Другие регистры
(13-20) Регистры идентификации, Аппаратурный сброс (используется вместе с тактовым питанием, то есть нужно дополнительно управлять Запись нуля не имеет эффекта, запись единицы запускает сброс, чтение единицы сигнализирует о состоянии сброса, чтение нуля сигнализирует об окончание сброса)

\subsection{Межмикросхемный звуковой интерфейс $I^2S$ (14)}
(02)
I2S – Integrated Inter-chip Sound (интегрированный межмикросхемный звук)
SPDIF – Sony-Philips Digital Interface
AES/EBU – Audio Engineering Society/European Broadcasting Union

аналоговые преобразуются при помощи АЦП. есть цифровые коаксиальные и оптические интерфейсы. Отдельно существует цифровой $I^2S$. Полученные цифровые данные могут быть переданы другим потребителям или выведены на внешние разъёмы.

(03) Устройства по $I^2S$ подключаются похожим на SPI образом, но есть два тактовых сигнала (битовой и словной синхронизации). Словная синхронизация позволяет синхронизировать каналы стерео.

(04) в составе микропроцессора имеется 4 $I^2S$. значит мы можем передавать 8 звуковых каналов звука в двух направлениях. Процессор имеет доступ к регистрам контроллеров и соответствующим контроллерам прерываний.

(05) при подключении всегда выделяется ведущий и ведомые. ведущий выдаёт сигналы словной и битовой синхронизации. Можно организовать как передачу данных от ведущего ведомому, так и наоборот. Также можно организовать двусторонний обмен данными или два подчинённых могут быть соединены мастером. Работает как SPI, при передаче такта передаётся один бит данных. словная синхронизация меняет значения канала (низкий уровень для левого канала и высокий уровень для правого).

(06) как и для $I^2C$  есть несколько форматов передачи данных. Так в формате DSP словная синхронизация передаётся импульсами и между импульсами передаётся и правый и левый канал, что позволяет передавать сразу 32-разрядные слова.

(07) контроллер устроен как $I^2C$. Для приёма и передачи данных существуют независимые сигналы, приходящие на синхронизатор. Если принимаем - мы ведомое устройство. Для формирования тактирования есть тактовый генератор, задающий не только такты, но и коэффициент пересчёта. Делители можно задавать. Тактовый генератор формирует события контроллера. Данные через сдвиговый регистр и буфер попадают на схему расширения поля знака для передачи данных в формате с фиксированной запятой. Для отдачи данных есть аналогичная (ответная) схема сужения знака, и как только сдвиговый регистр освободится, данные передаются в усилители (передатчик).

(08) Тактовое питание
\[ f_{I2S\_CLK} = \frac{f_{SYSCLK}}{2^{CLKDIV+1}}\]

\[ f_{I2S\_FS} = \frac{f_{I2S\_CLK}}{2^{FSDIV+1}}\]

Чтобы начать работать нужно разрешить тактирование. Всегда делим тактовую частоту процессора, других источников не будет. 

(09)Регистры расположены в адресном пространстве ввода-вывода. Базовые адреса: I2S0 – 2800h; I2S1 – 2900h; I2S2 – 2A00h; I2S3 – 2B00h.

\begin{table}[H]
  \centering
  \begin{tabular}{|r|c|c|} 
    \hline
Адрес & Обозначение & Описание \\
2800h & I2SSCTRL & Serializer Control Register (регистр управления) \\
2804h & I2SSRATE & Sample Rate Generator Register (регистр скорости выборки) \\
2808h & I2STXLT0 & Transmit Left Data 0 Register (регистр передачи левый 0) \\
280Сh & I2STXLT1 & Transmit Left Data 1 Register (регистр передачи левый 1) \\
2810h & I2STXRT0 & Transmit Right Data 0 Register (регистр передачи правый 0) \\
2814h & I2STXRT1 & Transmit Right Data 1 Register (регистр передачи правый 1) \\
2818h & I2SINTFL & Interrupt Flag Register (регистр флагов прерываний) \\
281Ch & I2SINTMASK & Interrupt Mask Register (регистр маски прерываний) \\
2820h & I2SRXLT0 & Receive Left Data 0 Register (регистр приема левый 0) \\
2824h & I2SRXLT1 & Receive Left Data 1 Register (регистр приема левый 1) \\
2828h & I2SRXRT0 & Receive Right Data 0 Register (регистр приема правый 0) \\
    282Ch & 2SRXRT1 & Receive Right Data 1 Register (регистр приема правый 1)\\
    \hline
  \end{tabular}
  \caption{Регистры $I^2S$ на примере 0-го контроллера}
\end{table}

PRCR (1C05h) – Peripheral Reset Control Register (регистр управления сбросом периферийных устройств)
PG4\_RST: LCD, I2S2, I2S3, UART, SPI.
PG3\_RST: MMC/SD0, MMC/SD1, I2S0, I2S1.

Запись нуля без эффекта, запись 1 запускает сброс, чтение 1 сигнализирует о состоянии сброса, чтение 0 – окончание сброса.

(10) Поскольку устройства работают асинхронно, существует вектор прерываний.
\begin{table}[H]
  \centering
  \begin{tabular}{|r|c|c|c|} 
    \hline
Вектор& Прерывание& Приоритет&          Адрес\\
00 RESET& Сброса и инициализации &00   &IVPD:00h \\
01 NMI&   Внутреннее немаскируемое &01 &IVPD:08h \\
02 INT0&  Внешнее по входу INT0 &03    &IVPD:10h \\
03 INT1&  Внешнее по входу INT1 &05    &IVPD:18h \\
04 TINT&  Агрегированное таймера &06   &IVPD:20h \\
05 PROG0& I2S0, MMC/SD0 передачи &07   &IVPD:28h \\
07 PROG1& I2S0,MMC/SD0 приема &10      &IVPD:38h \\
08 DMA&   Прямого доступа к памяти &11 &IVPD:40h \\
09 PROG2& I2S1,MMC/SD1 передачи &13    &IVPD:48h \\
11 PROG3& I2S1,MMC/SD1 приема &15      &IVPD:58h \\
13 SAR&   Агрегированное АЦП &18       &IVPD:68h \\
14 XTM2&  I2S2 передачи &21            &IVPD:70h \\
15 RCV2&  I2S2 приема &22              &IVPD:78h \\
16 XMT3&  I2S3 передачи &04            &IVPH:80h \\
17 RCV3&  I2S3 приема &09              &IVPH:88h \\
18 RTC&   Часов реального времени &12  &IVPH:90h \\
21 GPIO&  Портов ввода-вывода& 20      &IVPH:A8h \\
23 I2C&   Контроллера I2C& 24          &IVPH:B8h \\
    \hline
  \end{tabular}
  \caption{Регистры $I^2S$ на примере 0-го контроллера}
\end{table}

(11) Регистр управления

I2SSCTRL (2800h) – I2Sx Serializer Control Register (регистр управления)

\begin{itemize}
\item ENABLE – Enable (разрешение работы контроллера)
\item MONO – Mono (режим моно)
\item LOOPBACK – Loopback (режим обратной петли)
\item FSPOL – Frame-synchronization polarity (полярность кадровой синхронизации I2S\_FS: 0 – высокий уровень, 1 – низкий уровень). Без дополнительной информации мы не можем знать, перепутаны ли каналы.
\item CLKPOL – Сlock polarity (полярность битовой синхронизации I2S\_CLK: 0 – переход от 0 к 1, 1 –переход от 1 к 0)
\item DATADLY – Data delay (задержка данных: 0 – 1 бит, 1 – 2 бита)
\item PACK – Pack (упаковка данных: 0 – запрещена, 1 – разрешена)
\item SIGN\_EXT – Sign extension (расширение знака)
\item WDLNGTH – Word length(длина слова: 0 – 8 бит, 1 – 10 бит, 2 – 12 бит, 3 – 14 бит, 4 – 16 бит, 5 – 18 бит, 6 – 20 бит, 7 – 24 бита, 8 – 32 бита)
\item MODE – Mode (режим: 1 – ведущий, master; 0 – ведомый, slave)
\item FRMT – Format (формат: 0 – I2S, 1 – DSP)
\end{itemize}

(12) Упаковка данных. При уменьшении разрядности чисел с фиксированной запятой всегда усекается младшая часть, то есть при работе контроллера всегда пишутся только существенные данные.

(13) Регистры делителей и данных
I2SSRATE (2804h) – I2Sn Sample Rate Generator Register (регистр делителей)

\begin{itemize}
\item [] I2STXLT0 (2808h) – I2Sx Transmit Left Data 0 Register (регистр передачи левый 0)
\item [] I2STXLT1 (280Сh) – I2Sx Transmit Left Data 1 Register (регистр передачи левый 1)
\item [] I2STXRT0 (2810h) – I2Sx Transmit Right Data 0 Register (регистр передачи правый 0)
\item [] I2STXRT1 (2814h) – I2Sx Transmit Right Data 1 Register (регистр передачи правый 1)
\item [] I2SRXLT0 (2820h) – I2Sx Receive Left Data 0 Register (регистр передачи левый 0)
\item [] I2SRXLT1 (2824h) – I2Sx Receive Left Data 1 Register (регистр передачи левый 1)
\item [] I2SRXRT0 (2828h) – I2Sx Receive Right Data 0 Register (регистр передачи правый 0)
\item [] I2SRXRT1 (282Ch) – I2Sx Receive Right Data 1 Register (регистр передачи правый1)
\end{itemize}

\begin{itemize}
\item FSDIV – Frame-synchronization divider (делитель кадровой синхронизации: 0 – 8, 1 – 16, 2 – 32, 3 – 64, 4 – 128, 5 – 256)
\item CLKDIV – Clock divider (делитель битовой синхронизации: 0 – 2, 1 – 4, 2 – 8, 3 – 16, 4 – 32, 5 – 64, 6 – 128, 7 – 256)
\item DATA – Data (данные)
\end{itemize}

(14) Регистры прерываний
I2SINTFL (2818h) – I2Sx Interrupt Flag Register (регистр флагов прерываний)
I2SINTMASK (281Сh) – I2Sx Interrupt Mask Register (регистр масок прерываний)

\begin{itemize}
\item XMITSTFL – Stereo data transmit (флаг или маска прерывания по готовности стерео передатчика)
\item XMITMONFL – Mono data transmit (флаг или маска прерывания по готовности моно передатчика)
\item RCVSTFL – Stereo data receive (флаг или маска прерывания по готовности стерео приемника)
\item RCVMONFL – Mono data receive (флаг или маска прерывания по готовности моно приемника)
\item FERRFL – Frame-synchronization error (флаг или маска прерывания по ошибки кадровой синхронизации)
\item OUERRFL – Overrun or Underrun condition (флаг или маска прерывания по передержке или недодержке)
\end{itemize}

(15) Инициализация контроллера
\begin{enumerate}
\item Сброс PRCR[PGx\_RST] и ожидание нуля.
\item Подача тактового питания PCGCR1[I2SxCG]=0.
\item Сброс канала прямого доступа*.
\item Запрет прерываний и очистка флагов I2Sx.
\item Инициализация канала прямого доступа*.
\item Конфигурирование внешнего устройства I2S.
\item Разрешение прерываний.
\item Конфигурирование контроллера I2S:
  \begin{itemize}
  \item трассировка сигналов I2S на внешние входы;
  \item если I2S ведущее устройство, то задать тактовую частоту в I2SSRATE;  
  \item разрешить прерывания в I2SINTMASK;
  \item сконфигурировать I2SSCTRL.
  \end{itemize}
\item Обработка прерываний контроллера и канала
  \begin{itemize}
  \item Чтение I2SINTFL для сброса флагов прерываний.
  \item Чтение или запись данных в регистры данных I2S, если не используется канал прямого доступа.
  \item Возврат из прерывания.
  \end{itemize}
\item Завершение ввода-вывода
  \begin{itemize}
  \item Запрет прерываний и очистка флагов I2Sx.
  \item Останов канала прямого доступа*.
  \item Снятие тактового питания PCGCR1[I2SxCG]=0.
  \end{itemize}
\end{enumerate}

(17) Функции  $I^2S$

\begin{lstlisting}[language=C,style=CCodeStyle]
  port_write(0x2A08, 0x5678); // I2STXLT0
  port_write(0x2A0C, 0x1234); // I2STXLT1
  port_write(0x2A10, 0x5678); // I2STXRT0
  port_write(0x2A14, 0x1234); // I2STXRT1
  
  void i2s2_init(void) {
    int tmp = 0x04 < < 2; // WORD 16
    tmp |= 0x0082; // Master, Pack
    port_write(0x2A00, tmp); // 16 bit
    tmp = port_read(0x2A00); // I2SSCTRL
    tmp = 0x2 < < 3; // FS 32;
    tmp |= 0x0005; // Clock = CPU / 4
    port_write(0x2A04, tmp); // I2SSRATE
    _port_write: port_write(0x2A1C, 0x20);// I2SINTMASK
  }
\end{lstlisting}

\begin{lstlisting}[style=ASMStyle]
  .text
  .global _port_read
  .global _port_write

  ; int port_read(int reg)
  _port_read:
  MOV T0,AR0
  MOV port(*AR0), T0
  ret

  ; void port_write(int reg, int data)
  MOV T0,AR0
  MOV T1, port(*AR0)
  ret
\end{lstlisting}

(18) Определения $I^2S$
(19) Инициализация
(20) Секция прерываний
(21) Обработчик прерываний $I^2S$


\subsection{Аудиокодек (15)}
Кодек TLV320AIC3204
\begin{itemize}
\item Питание внутреннее (внешнее):
  \begin{itemize}
  \item аналоговое 1,5–1,95 В (1,1–3,6 В);
  \item цифровое 1,26–1,95 В (1,8–3,6 В);
  \item тактовое 8–192 кГц (512 кГц–50MГц).
  \end{itemize}
\item Входы-выходы:
  \begin{itemize}
  \item вход стерео и моно микрофона;
  \item выход стереонаушников;
  \item линейный стерео выход.
  \end{itemize}
\item Функции:
  \begin{itemize}
  \item стерео АЦП, от 8 до 192 кГц;
  \item стерео ЦАП , от 8 до 192 кГц;
  \item программируемое смещение и усиление;
  \item 6 простых и 3 дифференциальных входа.
  \end{itemize}
\end{itemize}

(5)
Питание кодека включается сигналом \code{LDO_SELECT}.
(6)
тактируется и ресетится микропроцессором. подключается к процессору по $I^2S$ для сигналов и $I^2C$ для управления.
(7)
Кодек подключается к интерфейсу $I^2S_2$.

(8) Обработка сигналов
И вход и выход заканчиваются звуковым интерфейсом (всё оцифровывается). Почти на каждом этапе приёма или передачи звука есть цифровое регулирование.

(9)
(10)
(11)

(14)
(15)
(16)

(17) Инициализация кодека
\begin{lstlisting}[language=C,style=CCodeStyle]
uint16 aic3204_start( uint16* tab, uint16 len) {
  // Локальные данные
  uint16 dat;
  uint8 reg, cmd;
  // Цикл по элементам таблицы
  while( --len > 0 ) {
    // Чтение текущего элемента
    dat = *tab++;
    // Распаковка текущего элемента
    reg = dat >> 8, cmd = dat & 0xFF;
    // Интерпретация данных
    if( reg == 0xFF )
      // Ожидание
      ret &= C5515_wait( cmd*10 );
    else
      // Запись в регистр кодека
      ret &= AIC3204_set( reg, cmd);
  }
  return ret;
}
\end{lstlisting}

(18)
(19)
(20)
Чтение-запись отсчетов
\begin{lstlisting}[language=C,style=CCodeStyle]
uint16 AIC3204_read( int16* left_input, int16* right_input) {
  int16 dummy;
  // Ожидание готовности приемника
  while(!(I2S2.INTFL & INTFL_RCVR)); // Чтение отсчета левого канала
  *left_input = I2S2.RXLT0;
  dummy = I2S2.RXLT1;
  // Чтение отсчета правого канала
  *right_input = I2S2.RXRT0;
  dummy = I2S2.RXRT1;
}

void AIC3204_write( int16 left_output, int16 right_output) {
  // Ожидание готовности передатчика
  while(!(I2S2.INTFL & INTFL_XMITR)); // Запись отсчета в левый канал
  I2S2.TXLT0 = left_output;
  I2S2.TXLT1 = 0;
  // Запись отсчета в правый канал
  I2S2.TXRT0 = right_output; I2S2.TXRT1 = 0;
}
\end{lstlisting}

\section{Стандартная библиотека (16)}
\begin{itemize}
\item \textbf{CSL} - Chip Support Library (библиотека поддержки) [P01] содержит функции
  \begin{itemize}
  \item синхронизации (\code{csl_ppl.h}), 
  \item питания (\code{csl_pwr.h}), 
  \item канала прямого доступа к памяти (\code{csl_dma.h}), 
  \item прерывания (\code{csl_irq.h}), 
  \item аналого-цифрового преобразователя (\code{csl_adc.h}), 
  \item входов-выходов общего назначения (\code{csl_gpio.h}), 
  \item интерфейса $I^2C$ (\code{csl_i2c.h}),
  \item ...
  \end{itemize}
\item \textbf{DSPLIB} (\code{dsplib.h}, \code{55xdspx.lib}) [P02, D09] содержит функции
  \begin{itemize}
  \item свертки, 
  \item корреляции, 
  \item КИХ- и БИХ-фильтрации, 
  \item адаптивной фильтрации, 
  \item быстрого преобразования Фурье, 
  \item математические функции, 
  \item матричные функции, 
  \item вспомогательные функции.
  \end{itemize}
\item \textbf{IMGLIB} (\code{imglib.h}, \code{55ximage.lib}) содежржит функции
  \begin{itemize}
  \item компрессии и декомпрессии, 
  \item анализа изображений, 
  \item фильтрации изображений, 
  \item преобразования форматов.
  \end{itemize}
\end{itemize}

\subsection{Библиотека обработки сигналов}
используется для цифровой обработки сигналов (см. \hRf{pic:SignalProcessing}). В общем, все преобразования повторяют \hRf{subsect:methods}.

В библиотеке присутствуют функции для 
\begin{itemize}
\item Быстрое преобразование Фурье (FFT)
  (25)
\item Фильтрация нерекурсивная (FIR) представлена функциями
  \begin{itemize}
  \item FIR direct form
\begin{verbatim}
ushort fir (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nx, ushort nh)
\end{verbatim}
  \item FIR direct form (DUAL−MAC)
\begin{verbatim}
ushort fir2 (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nx, ushort nh)
\end{verbatim}
  \item Symmetric FIR direct form
\begin{verbatim}
ushort firs (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nx, ushort nh2)
\end{verbatim}
  \item Complex FIR direct form
\begin{verbatim}
ushort cfir (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer, 
        ushort nx, ushort nh)
\end{verbatim}
  \item Фильтр с передискретизацией Decimating FIR filter
\begin{verbatim}
ushort firdec (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nh, ushort nx, ushort D)
\end{verbatim}
  \item Фильтр с передискретизацией Interpolating FIR filter
\begin{verbatim}
ushort firinterp (DATA *x, DATA *h,
        DATA *r, DATA *dbuffer, 
        ushort nh, ushort nx, ushort I)
\end{verbatim}
  \item КИХ Гильберта FIR Hilbert Transformer (преобразование Гильберта, нужно передавать коэффициенты, просчитанные заранее)
\begin{verbatim}
ushort hilb16 (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nx, ushort nh)
\end{verbatim}
  \item Решётчатый КИХ фильтр Lattice forward FIR filter (решетчатый фильтр)
\begin{verbatim}
ushort firlat (DATA *x, DATA *g, 
        DATA *r, DATA *pbuffer, 
        int nx, int nh)
\end{verbatim}
  \end{itemize}
\item Фильтрация рекурсивная (IIR) представлена функциями
  \begin{itemize}
  \item IIR cascade direct 4-biquad form 2
\begin{verbatim}
ushort iircas4 (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nbiq, ushort nx)
\end{verbatim}
  \item IIR cascade direct 5-biquad form 2
\begin{verbatim}
ushort iircas5 (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer,
        ushort nbiq, ushort nx)
\end{verbatim}
\item IIR cascade direct 5-biquad form 1
\begin{verbatim}
ushort iircas51 (DATA *x, DATA *h, 
        DATA *r, DATA *dbuffer, 
        ushort nbiq, ushort nx)
\end{verbatim}
\item Double-precision IIR filter
\begin{verbatim}
ushort iir32 (DATA *x, LDATA *h, 
        DATA *r, LDATA *dbuffer,
        ushort nbiq, ushort nr)
\end{verbatim}
\item Решётчатый БИХ фильтр Lattice inverse IIR filter
\begin{verbatim}
ushort iirlat (DATA *x, DATA *h, 
        DATA *r, DATA *pbuffer, 
        int nx, int nh)
\end{verbatim}
  \end{itemize}
\item Фильтрация адаптивная (DLMS)
  \begin{itemize}
  \item LMS FIR (delayed version)
\begin{verbatim}
ushort dlms (DATA *x, DATA *h, 
        DATA *r, DATA *des,
        DATA *dbuffer, DATA step, 
        ushort nh, ushort nx)
\end{verbatim}
\item Adaptive delayed LMS filter (fast implemented) (LMS – Least Mean Square, минимальная среднеквадратическая ошибка)
\begin{verbatim}
ushort dlmsfast (DATA *x, DATA *h, 
        DATA *r, DATA *des, 
        DATA *dbuffer, DATA step, 
        ushort nh, ushort nx)
\end{verbatim}
  \end{itemize}
\item Свертка (convolution)
  \begin{itemize}
  \item Convolution
\begin{verbatim}
ushort convol (DATA *x, DATA *h, 
        DATA *r, ushort nr, ushort nh)
\end{verbatim}
\item Convolution (DUAL−MAC)
\begin{verbatim}
ushort convol1 (DATA *x, DATA *h, 
        DATA *r, ushort nr, ushort nh)
\end{verbatim}
\item Convolution (DUAL−MAC)
\begin{verbatim}
ushort convol2 (DATA *x, DATA *h, 
        DATA *r, ushort nr, ushort nh)
\end{verbatim}
  \end{itemize}
\item Корреляция (CORR)
  \begin{itemize}
  \item Autocorrelation
\begin{verbatim}
ushort acorr (DATA *x, DATA *r, 
       ushort nx, ushort nr, type)
\end{verbatim}
\item Correlation
\begin{verbatim}
ushort corr (DATA *x, DATA *y, 
       DATA *r, ushort nx, 
       ushort ny, type)
\end{verbatim}
  \end{itemize}
\item Тригонометрические функции (SINE, ...)
  (28)
\item Векторные функции (SQRT, SUB, DIV, ...)
  (29-31)
\item Матричные функции (MUL, TRANS, ...)
  (32)
\item Вспомогательные функции (RAND, ...)
  (27)
\end{itemize}

\begin{table}[h!]
  \centering
  \begin{tabular}{||p{80mm}|p{80mm}||} 
    \hline
    БИХ & КИХ \\ [0.5ex] 
    \hline\hline
    Более эффективны & Менее эффективны \\
    Есть аналоговый эквивалент & Нет аналогового эквивалента \\
    Могут быть нестабильными & Всегда стабильные \\
    Нелинейная фазовая характеристика & Линейная фазовая характеристика \\
    Больше «звон» при наличии ложных сигналов & Меньше звон при наличии ложных сигналов \\
    Доступны средства САПР & Доступны средства САПР \\
    Децимация не влияет на эффективность & Децимация увеличивает эффективность \\
    \hline
  \end{tabular}
  \caption{Сравнение фильтров}
\end{table}

\subsection{Биквадратный фильтр}
(12)

\subsection{Решётчатый фильтр}
(13) Исторически были первые (сверху один элемент - это бих, снизу один элемент - это ких). аналог фильтра с обратной связью
\begin{itemize}
\item КИХ
  \[ K(z) = \frac{1}{G(z)}\]
\item БИХ
  \[ K(z) = H(z)\]
\end{itemize}
\subsection{Фильтр Гильберта}
Частный случай КИХ - фильтр Гильберта (14)
(на рисунке графике внизу формулы $h(t) = W(t) \frac{1 - \cos(\pi t)}{\pi t})$, окно Хемминга $W(t) = 1 - A + \frac{A\cos(2\pi t)}{(N - 1)}$)

\subsection{Адаптивный фильтр}
(19)

\subsection{Свёртка}
(21)
Циклическая свертка:
\begin{itemize}
\item [] $x[N + H - 1]$ – входной вектор 1; 
\item [] $h[H]$ – входной вектор 2;
\item [] $y[N]$ – выходной вектор.
\end{itemize}
Вычисляется без использования буфера задержки: 
\begin{itemize}
\item [] $h[i] = 0$ при $i < 0$ и $i >= H$;
\item [] $x[j] = 0$ при $j < 0$ и $j >= N + H - 1$.
\end{itemize}

\subsection{Корреляция}
(22)

\subsection{Согласованный фильтр}
(15)

\subsection{Спектральная обработка}
(24)

\subsection{Бит-реверсивная перестановка}
(26) выполняется перед БПФ

\section{Операционная система}
DSP/BIOS (Digital Signal Processing Base Instrumentation Operation System) – операционная система реального времени, предоставляющая следующие сервисы:
\begin{itemize}
\item мультизадачный планировщик задач;
\item аппаратурная абстракция устройств ввода-вывода данных;
\item независимый от устройств обмен потоками данных в реальном времени; – анализа поведения приложений и обмен данными с ними;
\item статическая конфигурация устройств ввода-вывода и приоритетов задач.
\end{itemize}
Создаёт псевдопараллельное исполнение задач системы. Программные модули DSP/BIOS:
\begin{itemize}
\item редактор конфигурирования;
\item модуль анализа реального времени; – модуль аппаратурной абстракции;
\item модуль ввода-вывода;
\item модуль управления потоками; – модуль синхронизации потоков.
\end{itemize}

\appendix
\setcounter{secnumdepth}{0}
\section*{Приложения}
\addcontentsline{toc}{section}{Приложения}
\renewcommand{\thesubsection}{\Alph{subsection}}

\subsection{Обозначения и сокращения}
\printnomenclature[23mm]

\newpage
\printbibliography[heading=bibintoc, title={Список литературы}]

\end{document}