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

Размещено на http://www.allbest.ru/

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

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

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

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

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. Номер варианта выбирается по последней цифре шифра. У меня номер шифра 02222, соответственно выбираем 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.000652 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	MatLab	Различие, %
q0	1,918	1.920	1,0
q1	-2,065	-1.995	-3,3
q2	0,614	0.545	-11

Приложение

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

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

//---------------------------------------------------------------------------

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

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

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

//---------------------------------------------------------------------------

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

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

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

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

//---------------------------------------------------------------------------

#include <vcl.h>

#include <math.h>

#include <systdate.h>

#include <inifiles.hpp>

#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^0

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<FI) goto S1;

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

if (Z1<FI) goto S1;

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<t){

//определяем дискретные моменты времени 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<yst*0.95)) qt=rt;

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

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')|(Key>'9'))&(Key!=',')&(Key!=8)) 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();

}

//---------------------------------------------------------------------------

Размещено на Allbest.ru