ОТЦ. Задание Исследование системы команд и элементов программирования цсп семейства adsp

Название	Задание Исследование системы команд и элементов программирования цсп семейства adsp
Дата	21.04.2022
Размер	427.96 Kb.
Формат файла
Имя файла	9_Laboratornaya_rabota_-_4_var_TsORS_2021.docx
Тип	Исследование #489046

Цель работы: закрепление теоретических знаний об архитектуре и системе команд цифровых сигнальных процессоров (ЦСП) путем их программирования и исследования на ПЭВМ.
З а д а н и е 1. Исследование системы команд и элементов программирования ЦСП семейства ADSP
Согласно варианту (4) системы ЦОРС, требовалось написать программу, выполняющую вычисления с записью в память.

Обобщенное описание инструкции имеет следующий вид:

где

символ | – разделитель возможных вариантов операндов;

Область памяти, в которой будут храниться данные:

1. DM – Data memory;

2. PM – Program Memory;

dreg – допустимые регистры данных:

Описание команды:

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

Операция вычисления должна быть безусловной. Допустимы все команды ALU, MAC и SHIFTER кроме команд непосредственных сдвигов, а также команд DIVS и DIVQ.

Фундаментальным принципом выполнения многофункциональных команд является то, что регистры (и память) считываются в начале цикла выполнения команда, а записываются в конце.

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

DM(I0, M0) = AR;

AR = AX0 + AY0;

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

Руководствуясь этим принципом, были созданы файлы A.dat, B.dat (Рисунок 1) массивы значений которых были изначально записаны в память программ (Рисунок 2), далее поданы на устройства АЛУ, а с выхода АЛУ записаны в память данных (Рисунок 3), после чего в выходной файл (Рисунок 4).

Рисунок 1 – Входные массивы

Рисунок 2 – Входные массивы в памяти программ (PM)

П р и м е ч а н и е – два нуля справа – ошибка отображения программы

Рисунок 3 – Сумма, записанная в память данных (DM)

Рисунок 4 – Значения суммы, выведенные в файл

Код программы представлен в таблице Таблица 1.
Таблица 1 – Код программы 1-го задания

.section/DM data1; // Выбор памяти - Data Memory
.section/PM pm_da; // Выбор памяти - Programm Memory

.VAR A_in[] = "A.dat"; // В переменную A_in приходят данные из файла A.dat

.VAR B_in[] = "B.dat"; // В переменную B_in приходят данные из файла B.dat
////////////////////////////////////////////////////
.section/pm program; // Область инициализации
start:

I4 = A_in; M4 = 1; L4 = 0; // DAG2

I5 = B_in; M5 = 1; L5 = 0; // DAG2

I0 = 0; M0 = 1; L0 = 0; // DAG1

CNTR = 4; // Кол-во циклов программы
////////////////////////////////////////////////////

DO _loop UNTIL CE; // Конечный цикл - будем в него попадать n = 4 раз

AX0 = PM(I4,M4); // A - Загружаю данные на вход x0 АЛУ

AY0 = PM(I5,M5); // B - Загружаю данные на вход y0 АЛУ

AR = AX0 + AY0; // В регистре AR будет результат суммы двух чисел, взятых из файлов A и B

DM(I0,M0) = AR ; // Загружаю в память результат суммы элемонтов А и B

_loop: io(0x100) = AR;
IDLE; // ожидание прерывания в энергосберегающем режиме

З а д а н и е 2. Программирование и отладка цифровых фильтров на основе ЦСП семейства ADSP
Структурная схема биквадратного звена для канонической формы реализации представлена на рисунке Рисунок 5.

Рисунок 5 – Структурная схема биквадратного звена для канонической формы его реализации
Такое звено описывается двумя разностными уравнениями:

Эти уравнения подобны паре разностных уравнений звена в прямой форме (Рисунок 6), если поменять местами его нерекурсивную и рекурсивную части и обозначения символов.

Рисунок 6 – Структурная схема биквадратного звена для прямой формы его реализации
Начальные нулевые условия для канонического звена имеют вид

. Они обеспечиваются обнулением сигнальной памяти до начала обработки. После обработки очередного отсчета сигнала осуществляются сдвиг сигнальной памяти. После этого на вход звена может подаваться следующий обрабатываемый отсчет сигнала.
Предварительно необходимо было синтезировать фильтр в программе РЦФ_СИНТЕЗ, согласно варианту. Коэффициенты синтезируемого фильтра приведены на рисунке Рисунок 7.

Рисунок 7 – Коэффициенты РЦФ каскадной формы реализации

Следующим шагом коэффициенты фильтра были переведены в двоичный дополнительный коде в формате 1.15 (Рисунок 8, третий столбец) и выгружены в файл Coef_hex.dat (Рисунок 9), с которого в дальнейшем и происходило считывание коэффициентов в программе (Таблица 2).

Рисунок 8 – Перевод коэффициентов в дополнительный код формата 1.15

Рисунок 9 – Коэффициенты, записанные в файл Coef_hex.dat

На вход РЦФ был подан единичный импульс, сигнал на выходе фильтра представлял из себя – импульсную характеристику. График выходного сигнала РЦФ в среде VisualDSP++ представлен на рисунке Рисунок 10.

Рисунок 10 – Отклик РЦФ
Для проверки правильности реализации РЦФ была собрана схема в SDCAD, на вход которой был также подан единичный импульс (Рисунок 11).

Рисунок 11 – Структурная схема РЦФ в SDCad

Отклик РЦФ фильтра среды SDCAD представлен на рисунке Рисунок 12.

Рисунок 12 – ИХ, синтезированного фильтра в SDCAD
Сравнивая Рисунок 10 и Рисунок 12 видно, что фильтр, синтезированный в среде разработки VisualDSP++ и фильтр, синтезированный в среде разработки SDCad идентичны.

Код программы представлен в таблице Таблица 2.
Таблица 2 – Код программы 2-го задания

#define n 100 // кол-во отсчётов выходного сигнала
#define Attenuation 0x2000 // Переменная для ослабления входного сигнала

#define Kanonicheskaya_forma 0x100 // Название выходного файла и его адресс
////////////////////////////
.section/data data1;
.VAR x_input[] = "xin.dat"; // Загружаем входной сигнал

.VAR Coef_hex[] = "Coef_hex.dat"; // Загружаем коэффициенты

.VAR y_out[100]; // Формируем массив для построения графика в окне VisualDSP++

.VAR W = 0x0;
.VAR W_minus_1 = 0; // Начальные услоивия w(-1)=0
.VAR W_minus_2 = 0;// Начальные услоивия w(-2)=0

.section/pm program;
start: I0 = x_input; M0 = 1; L0 = 0; // Задаю адрес для вх.сигнала

I1 = Coef_hex; M1 = 1; L1 = 0; // Считываем коэффициенты из файла
I2 = y_out; M2 = 1; L2 = 0;

CNTR = n;

SE = 1; // Задаю на сколько элементов сдвигать
DO the_end UNTIL CE; // 100 итераций
//рекурсивная часть - начало
//x(n)*Attenuation

MX0 = DM(I0,M0); //x(n)

MY0 = Attenuation; // Аттенюатор

MR = MX0*MY0(SS);
// a1*w(n-1)

I1 = Coef_hex + 3; // a1 = Coef_hex[3] - коэффициент a1 находится 3-им в таблице коэффов (счёт с нуля)

MX0 = DM(I1,M1); // MX0 = a1

MY0 = DM(W_minus_1); // w(n-1)

MR = MR+MX0*MY0(SS); // x(n)*Attenuation + a1*w(n-1)

// a2*w(n-2)

I1 = Coef_hex + 4; // a2 = Coef_hex[4]

MX0 = DM(I1,M1); // MX0 = a2

MY0 = DM(W_minus_2);

MR = MR+MX0*MY0(SS); // x(n)*Attenuation + a1*w(n-1) + a2*w(n-2)
//рекурсивная часть - конец

SR = ASHIFT MR1(HI); //сигнал из рекурсивной части умножаю на 2

DM(W) = SR1; // Записываю в w сигнал, умноженный на 2
//нерекурсивная часть - начало

//b0*w(n)

I1 = Coef_hex + 0; // b0 = Coeg_hex[0]

MX0 = DM(I1,M1); // MX0 = b0;

MY0 = DM(W);

MR = MX0*MY0(SS); //b0*w(n)

//b1*w(n-1)

I1 = Coef_hex + 1; // b1 = Coeg_hex[1]

MX0 = DM(I1,M1); // MX0 = b1;

MY0 = DM(W_minus_1);

MR = MR+MX0*MY0(SS); //b0*w(n) + b1*w(n-1)
//b2*w(n-2)

I1 = Coef_hex + 2; // b2 = Coeg_hex[2]

MX0 = DM(I1,M1); // MX0 = b2;

MY0 = DM(W_minus_2);

MR = MR+MX0*MY0(SS); //b0*w(n)+b1*w(n-1) + b2*w(n-2)
//нерекурсивная часть - конец

// Cдвигаю элементы памяти

MX0 = DM(W_minus_1);

DM(W_minus_2) = MX0; // записываю в w(n-2) значение w(n-1)

MX0 = DM(W);

DM(W_minus_1) = MX0;
DM(I2,M2) = MR1;
the_end: io(Kanonicheskaya_forma) = MR1;
RTI; // Выход из программы
stert.end: // Конец модуля

Вывод:
В ходе лабораторной работы были закреплены знания об архитектуре и системе команд цифровых сигнальных процессоров (ЦСП) путем их программирования и исследования на ПЭВМ.