Приведение входного сигнала к аналитическому виду

 

           В рассматриваемом примере курсовой работы входной сигнал Uвх(t) задан в виде графика (рис. 2). В этом случае необходимо перейти от графика к аналитическому выражению. Из графика видно, что Uвх(t) имеет два линейных участка. Поэтому аналитическая запись Uвх(t) будет иметь вид

 

       

 

Для определения величин  составим систему из двух уравнений для двух значений аргумента t.

 

 

Решая эти уравнения, получим для начального участка графика:

 

 

Составим аналогичную систему уравнений для второго участка графика, находим:

 

 

Подставляя значения  соответствующее исходному графику, в выражение для Uвх(t) получим

 

 

В результате такого перехода окончательно имеем:

 

где

 

Временной интервал наблюдения сигнала ограничен [tнач, tкон]. Для организации массива входных отсчетов сигнала необходимо этот временной интервал разбить на некоторое определенное конечное число точек N, для каждой из которых будет вычислено значение отсчета входного сигнала.

ЗАМЕЧАНИЕ: Массив отсчетов выходного сигнала должен быть в дальнейшем получен из значений выходного сигнала в тех же самых дискретных точках того же самого временного интервала.

           Полный текст программы, реализующий решение курсовой работы для варианта А=00, Б=00, В=00, приведен на рис. 3.

           Описание идентификаторов, использованных при решении поставленной задачи, приведено в табл. 1.

           Описание пользовательских подпрограмм приведено в табл. 2.

 

program kurs_1;

(Программа расчета характеристик выходного сигнала электрической цепи)

           uses Crt; {подключение модуля Crt}

           const

                          maxind=160;

           type

                          ArrayType=array [1..maxind] of real;    {описание глобальных параметров}

{-----------------------------------------------------------------------------------------------------------}

{Процедура ввода исходной информации}

 

procedure DATA (var n                             : integer;

                          var kl                            : byte;

                          var tn, tm, tk, Um, Uin2: real);

Begin

           writeln (`Введите нужное количество отсчетов сигнала`);

           write (`n=`);

           readln (n);

           writeln (`Введите признак kl = 1, если хотите вывести результат на монитор`)

           writeln (`или признак kl = 0, если хотите записать результаты в файлы f1 и f2`);

           write (`kl =`);

           readln (kl);

                      writeln (`Введите ваши исходные данные`);

                          writeln (`Начальный момент наблюдения входного сигнала`);

                          write (`tn=`);

                          readln (tn);

                          write (`Момент времени, разделяющий две ветви алгоритма`);

                          writeln (`расчета входного сигнала`);

                          write (`tm =`);

                          readln (tm);

           writeln (`Конечный момент времени наблюдения входного сигнала`);

           write (`tk =`);

                          readln (tk);

                          writeln (Значение входного напряж. соответствующего моменту времени tm`);

                          write (`Um =`);

                          readln (Um);

                          writeln (Заданный параметр передаточной характеристики`);

                          write (`Uin2=`);

                          readln (Uin2);

           end;   {of procedure DATA}

{-----------------------------------------------------------------------------------------------------------------------}

{Описание процедуры формирования массива входных отсчетов}

           procedure UIN (n                    : integer;

                                          kl                  : byte;

                                          tn, tm, tk, Um : real;

                      var    uin                : Arraytype); {список формальных параметров}

           var

                          t, a, b, del: real;

                          i: integer;

           begin

                          t:=tn;

                          del:=(tk-tn)/(n-1);

                          a:=um/(tm-tn);

                          b:=um/(tk-tm);

                          for i:=1 to n do

                                          begin

                                                          if t>tm

                                                                         then uin[i]:=b*(tk-t)

                                                                         else uin[i]:=a*(t-tn);

                                                          t:=t+del;

                                          end;

           end;   {of procedure UIN1}

{----------------------------------------------------------------------------------------------------------------------}

{Описание процедуры формирования массва выходных отсчетов}

 

procedure UOUT1(n    : integer;

                          kl       : byte;

                          Uin2  : real;

                          uin     : Arraytype;

           var    uout  : Array Type);

var                                                                   {описание локальных переменных}

           i: integer;

Begin

           for i:=1 to n do

                          if uin[i]<Uin2

                                          then uout[i]:=4

                                          else uout[i]:=(uin[i]-1)*(uin[i]-1);

           end;   {of procedure UOUT1}

{--------------------------------------------------------------------------------------------------------------------}

{Описание функции нахождения максимальнго значения выходного сигнала}

 

           function MAXI(n          : integer;

                                          uout  : Array Type):real:

                          var

                                          max: real;

i: integer;

           begin

                          max:=uout[i];

                          for i:=2 to n do

                                          if uout[i]>max

                                                          then max:=uout[i];

                          maxi:=max;

           end;   {of function MAXI}

{--------------------------------------------------------------------------------------------------------------------}

{Описание процедуры записи массивов входного и выходного сигналов}

{на диск в файлы с именами f1.prn и f2.prn}

 

           procedure WRITEINFO(n          : integer;

                                                          uin, uout: Array Type);

           var

                          f1, f2 : text;

                          I         : integer;

           begin

                          assign(f1, `f1.prn`);       {связывание и открытие файлов}

                          assign(f2, `f2.prn`);

                          rewrite(f1);

                          rewrite(f2);

                          for i:=1 to n do

                                          begin

                                                          writeln(f1,uin[i]:7:3);    {запись в файлах}

                                                          writeln(f2,uout[i]:7:3);

                                          end;

                          close(f1);         {закрытие файлов}

                           close(f2);

           end;   {of procedure WRITEINFO}

{---------------------------------------------------------------------------------------------------------------------}

{процедура вывода на экран результатов работы программы}

 

procedure REZULT(n            : integer;

                            kl            : byte;

                        uin, uout   : Array Type);

 

           var

                          i: integer;

                          begin

                          if kl=1         {признак вывода результатов на экран монитора}

                              then

                                          begin

                                          writeln(`Отсчеты входного сигнала`):

                                          for i:=1 to n do

                                                          writeln(`uin[`.i.`]=`uin[i]:7:3;       {вывод входных отсчетов}

                                          writeln(`Отсчеты выходного сигнала`);

                                          for i:=1 to n do

                                                          writeln(`uout[`.i.`]=`,uout[i]:7:3); {вывод вых. Отсчетов}

                                          writeln(`Макс. Значение вых. Сигнала=`,MAXI(n,uout):7:3);

                                          end

                          else

                                begin

                                            writeln;

                                            writeln;

                                            writeln(`Программа закончила свою работу. Массивы`);

           writeln(`входных и выходных отсчетов сформированы`);

           writeln(`и записаны в файлы f1.prn и f2.prn соответственно`);

                                                          end

                          end;   {of procedure REZULT}

{---------------------------------------------------------------------------------------------------------------------}

           var

                          n                        : integer;

                          kl                       : byte;               {глобальные параметры, напрямую недоступные}

                          tn, tm, tk, Um : real;            {ни одной из выше описанных процедур}

                          uin, uout          : Array Type;

 

{----------------------------------------------------------------------------------------------------------------------}

BEGIN            {of main}

           Circr;

           Data(n, kl, tn, tm, tk, Um, Uin2);

           Uin1 (n, kl, tn, tm, tk, Um, uin);

           Uout1(n, kl, Uin2, uin, uout);

           Writeinfo(n, uin, uout);

           Rezult(n, uin, uout);

           Readln

END. {of main}

 

Рис 3. Текст программы

 

Таблица идентификаторов

Таблица 1

Обозначение  в задаче	Индентификатор	Назначение
	n	Текущее значение количества отсчетов входного сигнала
	kl	Признак-ключ, определяющие режим работы kl=1, если вывод на монитор, kl – любое другое число, например 0, если вывод в файл на диск
Uвх(t)	uin	Массив для хранения отсчетов входного сигнала
Uвых(t)	uout	Массив для хранения отсчетов выходного сигнала
tнач	tn	Начальный момент наблюдения входного сигнала
tкон	tk	Конечный момент наблюдения входного сигнала
tм	tm	Параметр входного напряжения Uвх(t). Граничная точка, отделяющая две ветви Uвх(t)
Uм	Um	Параметр входного напряжения Uвх(t). Входное напряжение, соответствующее моменту времени tм
t	t	Текущий момент времени
a	a	Коэффициент, появляющийся при переходе от графического изображения сигнала к его аналитическому виду
b	b
	del	Временной интервал между двумя соседними отсчетами входного сигнала
	i	Счетчик цикла
Uвх1	Uin2	Параметр передаточной характеристики
	max	Переменная для хранения максимального значения выходного сигнала
	f1, f2	Логические имена файлов

 

 

Таблица описания пользовательских подпрограмм

Таблица 2

Подпрограмма	Входные и выходные параметры	Назначение
procedure DATA (var n: integer; var kl: byte; var tn, tm, tk, Um, Uin2: real);	Все формальные параметры процедуры являются выходными (var – параметры)	Позволяет ввести с клавиатуры необходимые для решения задачи исходные данные и передать эти данные в другие подпрограммы
procedure UIN1 (n: integer; kl: byte; tn, tm, tk, Um: real; var uin:Arraytype);	n, kl, tn, tm, tk, Um – входные параметры. Используются процедурой при формировании массива входных отсчетов сигнала. uin – выходной var – параметр хранит значения отсчетов входного сигнала	Процедура формирует массив отсчетов входного сигнала, который в дальнейшем может быть использован в других подпрограммах
procedure UOUT1 n integer; kl: byte; Uin2: real; uin: Arraytype; var uout: Array Type);	n, kl, Uin2, uin – входные параметры процедуры, используемые при формировании массива выходных отсчетов сигнала. uout – выходной var –параметр, хранит значения отсчетов выходного сигнала	Процедура формирует массив отсчетов выходного сигнала, который в дальнейшем может быть использован другими подпрограммами
function MAXI(n: integer; uout: Array Type): real;	n и uout – входные параметры значения, с их помощью функция рассчитывает свое единственное значение – максимальное значение выходного сигнала	Функция находит максимальное значение выходного сигнала и возвращает его в точку вызова
procedure WRITEINFO (n: integer; uin, uout: Array Type);	n, uin, uout – входные параметры, которые процедура использует для проведения операции записи массивов входных и выходных сигналов в файлы на диск	Процедура записывает отсчеты входного и выходного сигналов в нужном формате в файлы f1.prn и f2.prn соответственно
procedure REZULT (n integer; kl: byte; uin, uout: Array Type);	n, kl, uin, uout – входные параметры, используемые процедурой для вывода результатов на экран монитора	Выводит результат работы программы на экран монитора, если пользователь ввел с помощью процедуры Data нужное значение признака kl=1

 

 

Пояснения к тексту программы

 

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

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

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