Параметрический метод синтеза дискретного ПИД регулятора на ЭВМ

Курсовая работа

" Параметрический метод синтеза дискретного ПИД регулятора на ЭВМ"

алгоритм интегральный квадратичный регулятор

Задание на курсовую работу:

1. Для схемы замкнутой системы с дискретным регулятором (Р), импульсным элементом, формирователем импульсов (фи) и непрерывным объектом управления (см. рис. 1) необходимо разработать алгоритм оптимизации коэффициентов дискретного регулятора с законом ПИД по минимуму интегрального квадратичного критерия I =.

2. Алгоритм должен содержать:

— Подробное описание метода интегрирования непрерывных дифференциальных уравнений объекта управления. Уравнения необходимо получить в форме Коши по передаточной функции ОУ.

— Получение и описание дискретных алгоритмов управления регулятора.

— Алгоритм расчета формирователя импульсов нулевого порядка.

— Алгоритмы минимизации интеграла I как функции коэффициентов дискретного регулятора q0, q1, q2.

3. Составить программу расчёта оптимальных параметров регулятора на основе описанных алгоритмов.

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

Рис. 1

На схеме (рис. 1) введены следующие обозначения:

Р регулятор, ФИ формирователь прямоугольных импульсов, ОУ объект управления, импульсный элемент (квантователь),

g (t) задающее воздействие,

?(t) ошибка системы,

T такт квантования,

UT (t) управляющий сигнал в виде решетчатой функции,

UT*(t) управляющий сигнал в виде прямоугольных импульсов,

f (t) возмущающее воздействие,

y (t)регулируемая величина.

Передаточная функция дискретного регулятора, обеспечивающего ПИД закон управления:

Передаточная функция объекта управления:

где

k0 — коэффициент усиления объекта управления (k0 =1), а остальные параметры даны в таблице № 1. Номер варианта выбирается по последней цифре шифра. У меня номер шифра 2 222, соответственно выбираем 2-ой вариант.

Метод интегрирования непрерывных дифференциальных уравнений (ДУ) объекта управления

Передаточную функцию (ПФ) объекта разобьем на 3 звена 1-го порядка:

Получим по каждой ПФ ДУ: Запишем в форме Коши:

Аналогично для остальных звеньев:

Начальные условия в момент времени принимаем равными нулю. Входной управляющий сигнал получаем от регулятора, выходные значения считаем последовательно по каждому уравнению-звену. Выходные значения каждого звена в момент времени считаем, зная его значение и значение его производной в момент времени с помощью итерационного метода Эйлера. Сущность метода состоит в том, за время производная изменяется незначительно и считая её в течении времени неизменной, можем записать:

Потом по ДУ в форе Коши вычисляем новое значение производной и повторяем итерации необходимое число раз для заданного интервала времени.

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

Дискретный алгоритм управления регулятора получим по его аналоговому прототипу — непрерывному пропорционально-интегрально-дифференциальному (ПИД) регулятору. Уравнение регулятора в аналоговом виде:

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

Используя какой-либо численный метод расчета интегралов (в данной работе — метод прямоугольников) и аппроксимируя производную (в данной работе разностным линейным методом назад) мы можем написать это уравнение для любого момента времени t=mT:

(1)

Вычисление суммы для интеграла в каждом такте квантования слишком затратная операция и мы должны перевести уравнение в рекуррентную форму. Запишем уравнение (1) для момента времени m-1:

Вычтем из уравнения (1) уравнение (2):

Приведем уравнение к стандартному виду:

Получим по разностному уравнению ДПФ регулятора:

Запишем по положительным степеням z:

Формирователь импульсов (интерполятор) нулевого порядка

Дискретный регулятор выдает управляющее воздействие только в моменты времени mT замыкания ключа. Для непрерывного объекта управления необходимо непрерывное управляющее воздействие. Интерполятор 0-го порядка на период между замыканиями ключа запоминает и поддерживает на своем выходе значение UT (t).

Алгоритм минимизации интеграла I

Задаем начальные значения коэффициентов регулятора q0, q1, q2. В ходе моделирования переходного процесса рекуррентно считаем интеграл критерия оптимизации I, используем метод прямоугольников. Отличие от метода трапеций только в том, что в методе трапеций от первого и последнего значения берется половинка. При большом числе разбиений потеря точности незначительная.. После окончания моделирования (в данной работе время моделирования постоянное) получаем значение критерия оптимизации I, который зависит от коэффициентов q0-q2.

Получаем функциональную зависимость. Величину I минимизируем с помощью метода минимизации функции нескольких переменных Хука-Дживса (алгоритм метода взят готовый из курса «Численные методы»).

Программа расчёта оптимальных параметров регулятора

Мы получили все уравнения и алгоритмы, необходимые для численной параметрической оптимизации системы управления с дискретным регулятором. На основе вышеуказанных алгоритмов составлена программа OptimizeD. Программа написана в среде Borland C++ Builder 5. Исходный текст программы приведен в приложении 1.

Результаты расчетов

Переходный процесса с начальными значениями коэффициентов регулятора:

Рис.

Рис.

Переходный процесс при других значениях коэффициентов регулятора:

q0=2,01 q0=1,82

Применение MatLab для оптимизации системы управления с дискретным регулятором

Для оптимизации системы управления по заданному критерию удобно воспользоваться библиотекой Simulink Response Optimization. (оптимизация реакции системы). Составим модель системы в Simulink:

Рис.

Критерий оптимизации также посчитаем в Simulink и подадим на блок Signal Constraint. Блок Signal Constraint подбирает произвольно указанные параметры системы с такой целью (Goals), чтобы либо заставить (Enforce) уложиться подаваемый на блок сигнал в заданные границы (Enforce signal bounds), либо приблизить (отслеживать — Tracks) его к заданной кривой (Tracks reference signal).

Для того чтобы оптимизировать параметры регулятора, зададим их в виде переменных q0, q1,q2. Укажем начальные значения переменных (и заодно объявим сами переменные) в окне команд:

>> q0=0.5;

>> q1=-1;

>> q2=2;

Далее надо настроить блок Signal Constraint. Optimization->Tuned Parameters. Укажем, какие переменные из Workspace использовать для оптимизации, а также их границы и начальные значения.

Рис.

В качестве цели оптимизации выберем Tracks reference signal. Зададим желаемое изменение критерия оптимизации в ходе переходного процесса по точкам. Goals->Desired Response (желаемая реакция).

Рис.

Проведем оптимизацию. Пунктирной линией показано желаемое значение. Черной линией показано нарастание интеграла I, в ходе переходного процесса. Хорошо видно, что интеграл стремится к вполне определенному значению, т. е. существует.

Рис Ход процесса и результаты:

max Directional First-order

Iter S-count f (x) constraint Step-size derivative optimality Procedure

0 1 182.61 0

1 15 149.619 0 0.333 685 350

2 24 98.4927 0 0.25 330 128

3 33 50.8143 0 0.172 66.2 43.8

4 40 42.7297 0 0.646 21 11.8

5 47 36.0404 0 1 -0.876 9.52

6 54 35.0789 0 1 -0.434 5.87

7 61 34.8456 0 1 0.394 3.84

8 68 34.8076 0 1 0.0233 0.734

9 75 34.7892 0 1 -0.652 0.116

Optimization terminated due to slow progress in parameter or objective values.

To optimize further, go to Optimization Options and decrease the parameter and/or function tolerances.

q0 = 1.9207

q1 = -1.9958

q2 = 0.5454

Вид получившегося переходного процесса:

>>plot (ScopeData.time, ScopeData.signals.values)

Рис.

Сравним значения коэффициентов, с полученными с помощью программы OptimizeD:

Таблица

Приложение

Исходный текст программы OptimizeD

Модуль MainCode. cpp Остальные файлы проекта создаются компилятором автоматически и не приведены в целях сокращения объема.

//—————————————————————————————————————;

// Программа расчета переходного процесса для курсовой по ЦСУ

// В целях максимального упрощения и «прозрачности» программы,

// исключены все элементы ООП, а также расчет выполняется методом Эйлера

//—————————————————————————————————————;

// В программе считается очень много лишнего, в первую очередь

// пересчет графиков в процессе оптимизации, поэтому работа её

// медленнее чем это возможно как минимум в 100 раз. При отключении

// графики процесс оптимизации занимает менее 1 сек даже при 1000 шагов.

//—————————————————————————————————————;

#include

#include

#include

#include

#pragma hdrstop

#include «MainCode.h»

//—————————————————————————————————————;

#pragma package (smart_init)

#pragma resource «*.dfm»

TMainForm *MainForm; //указатель на главную форму

//параметры расчета. Для упрощения программы объявлены глобальными.

//параметры интегрирования

float dt; //шаг интегрирования

float t; //время интегрирования

//параметры объекта

float tau1; //постоянная времени 1

float tau2; //постоянная времени 2

float tau3; //постоянная времени 3

//параметры регулятора

float T; //длительность такта квантования в сек.

float q0; //коэффициент при z⁰

float q1; //коэффициент при z^-1

float q2; //коэффициент при z^-2

//параметры оптимизации. Тоже глобальные переменные.

float r; //коэффициент r

float I; //сам критерий

int NC; //число итераций

//—————————————————————————————————————;

//обработчик нажатия кнопки «Выполнить оптимизацию» — алгоритм Хука-Дживса

void __fastcall TMainForm: Button1Click (TObject *Sender)

{

//загрузка параметров расчета

LoadParam ();

//сброс графика «Ход оптимизации»

NC=0;

Chart1->Series[0]->Clear ();

Chart1->Title->Text->Strings[1]="Оптимизация системы начата" ;

Button1->Enabled=false;

Button1->Caption="Идет процесс" ;

//начали измерение времени

TDateTime Time;

Time=Time.CurrentTime ();

/*———————Cам алгоритм. Взят готовый.—————————————*/

/*Необходимо задать начальное значение шага H, общего для всех переменных.

Начальные значения аргументов Z[1] и Z[2] в точках минимума функции F.

Число переменных функции N. Обращение из процедуры происходит лишь к процедуре FUNK. Минимально допустимое значение измельчения шага задается в программе в виде оператора if K<1E-15 …(см. содержимое метки 7:) */

int i, J, PS, BS, N;

float K, H, FI, FB, Z1;

float Y[10], P[10], B[10], Z[10];

H=0.1; N=3; K=H; Z[1]=q0; Z[2]=q1;Z[3]=q2;

for (i=1;i<=N;i++)

{

Y[i]=Z[i]; P[i]=Z[i]; B[i]=Z[i];

}

FUNK (Z); Z1=I;

FI=Z1; PS=0; BS=1; J=1; FB=FI;

S4:

Z[J]=Y[J]+K; FUNK (Z); Z1=I;

if (Z1

Z[J]=Y[J]-K; FUNK (Z); Z1=I;

if (Z1

Z[J]=Y[J]; goto S2;

S1:

Y[J]=Z[J];

S2:

FUNK (Z); Z1=I; FI=Z1;

if (J==N) goto S3;

J=J+1; goto S4;

S3:

if (FI<(FB-1E-6)) goto S5;

if ((PS==1)&(BS==0)) goto S6;

goto S7;

S6:

for (i=1;i<=N;i++)

{

P[i]=B[i]; Y[i]=B[i]; Z[i]=B[i];

}

FUNK (Z); Z1=I; BS=1; PS=0; FI=Z1; FB=Z1; J=1; goto S4;

S7:

K=K/10;

if (K<1E-6) goto S8;

J=1; goto S4;

S5:

for (i=1;i<=N;i++)

{

P[i]=2*Y[i]-B[i]; B[i]=Y[i]; Z[i]=P[i]; Y[i]=Z[i];

}

FUNK (Z); Z1=I; FB=FI; PS=1; BS=0; FI=Z1; J=1; goto S4;

S8:

/*——————— Алгоритм закончился. ——————————————-*/

//показали результаты

Time=Time.CurrentTime ()-Time;

Chart1->Title->Text->Strings[1]=

" Оптимизация системы проведена за «+IntToStr (NC)+» шагов и «+Time;

Button1->Enabled=true;

Button1->Caption="Выполнить оптимизацию" ;

}

//—————————————————————————————————————;

//функция-адаптер FUNC. Запускает функцию расчета переходного процесса CompProcess,

//а также обновляет изображение в окне программы. Наличие её вызвано присутвием

//режима ручной подгонки, а также нежеланием что-либо менять в готовой процедуре

//алгоритма Хука-Дживса

void __fastcall TMainForm: FUNK (float *Z)

{

static int i;

q0=Z[1];

q1=Z[2];

q2=Z[3];

StringGrid2->Cells[1][7]=FloatToStrF (q0,ffGeneral, 4,5);

StringGrid2->Cells[1][8]=FloatToStrF (q1,ffGeneral, 4,5);

StringGrid2->Cells[1][9]=FloatToStrF (q2,ffGeneral, 4,5);

CompProcess ();

ShowOptimize ();

i++; if (!(i%10)) Application->ProcessMessages ();

}

//—————————————————————————————————————;

//расчет переходного процесса в системе

void __fastcall TMainForm: CompProcess (void)

{

//переменные системы

float g; //задающее воздействие

float E; //ошибка системы в текущий такт E (m)

float E1; //ошибка системы, задержанная на 1 такт E (m-1)

float E2; //ошибка системы, задержанная на 2 такта E (m-2)

float U; //значение на выходе ФИ регулятора

float x1; //значение на выходе 1-го звена объекта

float x2; //значение на выходе 2-го звена объекта

float y; //значение на выходе 3-го звена объекта — значение на выходе системы

float DER1; //значение 1-ой производной для всех звеньях объекта,

//т.к. её значение вычисляется каждый раз заново, нет

//необходимости хранить её значение отдельно для каждого звена

//переменные для определения дискретных моментов времени mT срабатывания регулятора

int NSkip, NS;

//служебные переменные расчета

float rt; //текущее время в сек.

float qt; //время переходного процесса в сек.

float yst; //установившийся значение, используется для

//расчета времени переходного процесса, вводится заранее

float nmax;//максимальное значение вых сигнала, используется для

//расчета перерегулирования

DWORD i, m; //счетчики

AnsiString str;

//задаем начальное состояние расчета

rt=0;nmax=0;

//задаем задающее воздействие и установившиеся значение

g=1;yst=g;

//задаем начальное состояние регулятора

E=0;E1=0;U=0;

//задаем начальное состояние объекта

x1=0;x2=0;y=0;

//задаем начальное состояние критерия оптимизации

I=0;

//определяем сколько шагов интегрирования пропускать

NSkip=T/dt;NS=0;

//записываем скорректированое значение длительности такта

StringGrid2->Cells[1][6]=FloatToStrF (NSkip*dt, ffGeneral, 7,7);

//сбрасываем графики

for (i=0;i<5;i++) Chart->Series[i]->Clear ();

//выводим в график только 1000 точек для скорости

m=t/(dt*1000); if (m==0) m=1;

//проводим интегрирование

while (rt

//определяем дискретные моменты времени mT — в эти моменты срабатывает регулятор

if (!(NS%NSkip)){

//считаем работу регулятора

//считаем ошибки системы — значение на выходе уст-ва сравнения

E2=E1;

E1=E;

E=g-y;

//с выхода уст-ва сравнения подаем сигнал на регулятор

U=U+q0*E+q1*E1+q2*E2;

//выводим выходное значение регулятора на график

Chart->Series[4]->AddXY (rt, U," «, clBlue);

}

NS++;

//в переменной U выходное значение регулятора запоминается до

//следующего такта квантования. Необходимости в специальном формирователе

//импульсов нет.

//с выхода регулятора подаем сигнал на звенья объекта

//объект считаем самым простым способом — методом Эйлера

//1-ое звено

DER1=(U-x1)/tau1;

x1=x1+DER1*dt;

//2-ое звено

DER1=(x1-x2)/tau2;

x2=x2+DER1*dt;

//выход системы. 3-ие звено

DER1=(x2-y)/tau3;

y=y+DER1*dt;

//определяем время переходного процесса

if ((y>yst*1.05)|(y

//определяем максимальное значение

if (y>nmax) nmax=y;

//выводим очередное выходное значение системы в график

i++; if (!(i%m)) Chart->Series[0]->AddXY (rt, y," «, clGreen);

//увеличиваем текущее время на шаг интегрирования

rt=rt+dt;

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

//отличие от метода трапеций только в том, что в методе трапеций от

//первого и последнего значения берется половинка. При большом числе

//разбиений разница получается небольшая.

I=I+E*E+r*(U-g)*(U-g);

}

I=I*dt;

//рисуем на графике линии ymax, ymin и вертикальную — время

Chart->Series[1]->AddXY (0,yst*1.05," «, clRed);

Chart->Series[1]->AddXY (t, yst*1.05," «, clRed);

Chart->Series[2]->AddXY (0,yst*0.95," «, clRed);

Chart->Series[2]->AddXY (t, yst*0.95," «, clRed);

Chart->Series[3]->AddXY (qt, 0," «, clRed);

Chart->Series[3]->AddXY (qt, yst*1.05," «, clRed);

//выводим надпись о времени переходного процесса

if (fabs (t-qt)<=dt*10) str="Время п/п — процесс не закончился" ;

else str="Время п/п="+FloatToStrF (qt, ffFixed, 5,4)+" сек" ;

Chart->Title->Text->Strings[1]=str;

//считаем и выводим перерегулирование

Chart->Title->Text->Strings[2]="Перерегулирование «+

FloatToStrF ((nmax/g-1)*100,ffFixed, 5,4)+" %" ;

}

//—————————————————————————————————————;

//——————————-служебные функции программы—————————————//

//конструктор объекта TMainForm. Вызывается автоматически при создании объекта

//TMainForm, т. е. один раз при запуске программы

__fastcall TMainForm: TMainForm (TComponent* Owner)

: TForm (Owner)

{

//инициализация окна параметров

StringGrid2->Cells[0][0]="Имя" ;

StringGrid2->Cells[1][0]="Значение" ;

StringGrid2->Cells[0][1]="dt" ;

StringGrid2->Cells[0][2]="t" ;

StringGrid2->Cells[0][3]="tau1″ ;

StringGrid2->Cells[0][4]="tau2″ ;

StringGrid2->Cells[0][5]="tau3″ ;

StringGrid2->Cells[0][6]="T" ;

StringGrid2->Cells[0][7]="q0″ ;

StringGrid2->Cells[0][8]="q1″ ;

StringGrid2->Cells[0][9]="q2″ ;

StringGrid2->Cells[0][10]="r" ;

StringGrid2->Col=1;

StringGrid2->Row=7;

//загрузка параметров

IniFile = new TIniFile (ChangeFileExt (Application->ExeName, «.ini»));

LoadParam ();

}

//—————————————————————————————————————;

//деструктор объекта TMainForm. Вызывается автоматически при уничтожении объекта

//TMainForm, т. е. один раз при завершении программы

void __fastcall TMainForm: FormDestroy (TObject *Sender)

{

SaveParam ();

delete IniFile;

}

//—————————————————————————————————————;

//загрузка параметров из окна, или из файла, или при их отсутствии по-умолчанию

void __fastcall TMainForm: LoadParam (void)

{

//загружаем сначала в окно

if (StringGrid2->Cells[1][1]=="")

StringGrid2->Cells[1][1]=IniFile->ReadString («Integration» ," dt", 0.01);

if (StringGrid2->Cells[1][2]=="")

StringGrid2->Cells[1][2]=IniFile->ReadString («Integration» ," t", 10);

if (StringGrid2->Cells[1][3]=="")

StringGrid2->Cells[1][3]=IniFile->ReadString («Plant» ," tau1″, 0.3);

if (StringGrid2->Cells[1][4]=="")

StringGrid2->Cells[1][4]=IniFile->ReadString («Plant» ," tau2″, 0.2);

if (StringGrid2->Cells[1][5]=="")

StringGrid2->Cells[1][5]=IniFile->ReadString («Plant» ," tau3″, 0.7);

if (StringGrid2->Cells[1][6]=="")

StringGrid2->Cells[1][6]=IniFile->ReadString («Controller» ," T", 0.4);

if (StringGrid2->Cells[1][7]=="")

StringGrid2->Cells[1][7]=IniFile->ReadString («Controller» ," q0″, 0.5);

if (StringGrid2->Cells[1][8]=="")

StringGrid2->Cells[1][8]=IniFile->ReadString («Controller» ," q1″ ,-1);

if (StringGrid2->Cells[1][9]=="")

StringGrid2->Cells[1][9]=IniFile->ReadString («Controller» ," q2″, 2);

if (StringGrid2->Cells[1][10]=="")

StringGrid2->Cells[1][10]=IniFile->ReadString («Optimize» ," r", 0.2);

//а потом из окна считываем значения в переменные

dt=StrToFloat (StringGrid2->Cells[1][1]);

t=StrToFloat (StringGrid2->Cells[1][2]);

tau1=StrToFloat (StringGrid2->Cells[1][3]);

tau2=StrToFloat (StringGrid2->Cells[1][4]);

tau3=StrToFloat (StringGrid2->Cells[1][5]);

T=StrToFloat (StringGrid2->Cells[1][6]);

q0=StrToFloat (StringGrid2->Cells[1][7]);

q1=StrToFloat (StringGrid2->Cells[1][8]);

q2=StrToFloat (StringGrid2->Cells[1][9]);

r=StrToFloat (StringGrid2->Cells[1][10]);

}

//—————————————————————————————————————;

//сохранение параметров в файл

void __fastcall TMainForm: SaveParam (void)

{

IniFile->WriteString («Integration» ," dt", FloatToStrF (dt, ffGeneral, 3,4));

IniFile->WriteString («Integration» ," t", FloatToStrF (t, ffGeneral, 3,4));

IniFile->WriteString («Plant» ," tau1″, FloatToStrF (tau1,ffGeneral, 3,4));

IniFile->WriteString («Plant» ," tau2″, FloatToStrF (tau2,ffGeneral, 3,4));

IniFile->WriteString («Plant» ," tau3″, FloatToStrF (tau3,ffGeneral, 3,4));

IniFile->WriteString («Controller» ," T", FloatToStrF (T, ffGeneral, 3,4));

IniFile->WriteString («Controller» ," q0″, FloatToStrF (q0,ffGeneral, 3,4));

IniFile->WriteString («Controller» ," q1″, FloatToStrF (q1,ffGeneral, 3,4));

IniFile->WriteString («Controller» ," q2″, FloatToStrF (q2,ffGeneral, 3,4));

IniFile->WriteString («Optimize» ," r", FloatToStrF (r, ffGeneral, 3,4));

}

//—————————————————————————————————————;

//выводит ход оптимизации на график

void __fastcall TMainForm: ShowOptimize (void)

{

NC++;

Chart1->Series[0]->AddXY (NC, I," «, clRed);

}

//—————————————————————————————————————;

//сброс графика ход оптимизации

void __fastcall TMainForm: Button2Click (TObject *Sender)

{

NC=0;

Chart1->Series[0]->Clear ();

}

//—————————————————————————————————————;

//фильтрация ввода

void __fastcall TMainForm: StringGrid2KeyPress (TObject *Sender, char &Key)

if (Key=='.') Key=',';

if (((Key<'0')

//—————————————————————————————————————;

//передвигаем контекстное меню под курсор мыши

void __fastcall TMainForm: ChartContextPopup (TObject *Sender,

TPoint &MousePos, bool &Handled)

{

PopupMenu->Popup (MousePos.x+MainForm->Left, MousePos. y+MainForm->Top);

}

//—————————————————————————————————————;

//копирование графика в буфер обмена для удобства использования

void __fastcall TMainForm: N1Click (TObject *Sender)

{

Chart->CopyToClipboardBitmap ();

}

//—————————————————————————————————————;

//копирование окна в буфер обмена

void __fastcall TMainForm: N2Click (TObject *Sender)

{

Graphics:TBitmap *Bitmap = new Graphics: TBitmap ();

TRect FormRect;

FormRect = MainForm->ClientRect;

Bitmap->Height=FormRect.bottom;

Bitmap->Width=FormRect.right;

Bitmap->Canvas->BrushCopy (FormRect, Bitmap, FormRect, clWhite);

Bitmap->Canvas->CopyRect (FormRect, MainForm->Canvas, FormRect);

Clipboard ()->Assign (Bitmap);

delete Bitmap;

}

//—————————————————————————————————————;

//реакция на движение ползунка «ручная подгонка параметров»

void __fastcall TMainForm: TrackBar1Change (TObject *Sender)

{

static float K;

static int Col, Row;

float V;

if (TrackFlag){

Col=StringGrid2->Col;

Row=StringGrid2->Row;

if (StringGrid2->Cells[Col][Row]=="") StringGrid2->Cells[Col][Row]="0,1″ ;

K=StrToFloat (StringGrid2->Cells[Col][Row]);

TrackFlag=false;}

V=TrackBar1->Position;V=V/40;V=K*exp (V);

StringGrid2->Cells[Col][Row]=FloatToStrF (V, 2,6,5);

LoadParam ();

CompProcess ();

ShowOptimize ();

}

//—————————————————————————————————————;

//указание, какой параметр менять ползунком

void __fastcall TMainForm: StringGrid2Click (TObject *Sender)

{

TrackFlag=true;

TrackBar1->Position=0;

}

//реакция на нажатие кнопки «одиночный расчет переходного процесса»

//—————————————————————————————————————;

void __fastcall TMainForm: Button3Click (TObject *Sender)

{

LoadParam ();

CompProcess ();

}

//—————————————————————————————————————;

Размещено на