Документация Engee
Notebook

Подключение моделей

Открыть пример в Engee

В этом примере изучим, как моделировать соединение LTI систем в Engee. От простых последовательных и параллельных подключений для сложных блок-схем.

Обзор

Engee предоставляет ряд функций , которые помогут вам создать объединения моделей LTI. К ним относятся функции:

  • Последовательное и параллельное подключение (series, parallel)
  • Подключение с обратной связью (feedback, feedback2dof)
  • Конкатенация ввода и вывода ([ , ], [ ; ], append, array2mimo)
  • Общее построение блок-схем (connect)

Для иллюстрации примеров подключим необходимые библиотеки и создадим две системы со следующими передаточными функциями:

In [ ]: 
using ControlSystems
In [ ]: 
H1 = tf(2,[1, 3, 0])
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoRational{Int64}}
   2
--------
s^2 + 3s

Continuous-time transfer function model
In [ ]: 
H2 = zpk([],[-5],5)
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Int64}}
   1
5-----
 s + 5

Continuous-time transfer function model

Последовательное соединение

Используйте оператор * или функцию series для последовательного подключения моделей LTI, например:

gsconnectingmodels_01.png

In [ ]: 
H = H2 * H1
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Complex{Int64}}}
          1
10-----------------
  (s + 5)(s + 3)(s)

Continuous-time transfer function model
In [ ]: 
H = series(H1,H2)
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Complex{Int64}}}
          1
10-----------------
  (s + 5)(s + 3)(s)

Continuous-time transfer function model

Параллельное соединение

Используйте оператор + или функцию parallel для параллельного подключения моделей LTI, например:

gsconnectingmodels_02.png

In [ ]: 
H = H1 + H2
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Float64, ComplexF64}}
   (1.0s + 2.6433981132056608)(1.0s + 0.7566018867943395)
5.0------------------------------------------------------
               (1.0s + 3.0)(1.0s)(1.0s + 5.0)

Continuous-time transfer function model
In [ ]: 
H = parallel(H1,H2)
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Float64, ComplexF64}}
   (1.0s + 2.6433981132056608)(1.0s + 0.7566018867943395)
5.0------------------------------------------------------
               (1.0s + 3.0)(1.0s)(1.0s + 5.0)

Continuous-time transfer function model

Соединение с обратной связью

Стандартный вид структурной схемы системы с оратной отрицательной связью:

gsconnectingmodels_03.png

Чтобы определить замнутую системы используйте функцию feedback.

In [ ]: 
H = feedback(H1,H2)
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Float64, ComplexF64}}
                                    1.0s + 5.0
2.0-----------------------------------------------------------------------------
   (1.0s + 5.663076827457541)(1.0s^2 + 2.3369231725424586s + 1.7658245340262375)

Continuous-time transfer function model

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

In [ ]: 
H = feedback(H1, H2, pos_feedback = true)
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Float64, ComplexF64}}
                                   1.0s + 5.0
2.0---------------------------------------------------------------------------
   (1.0s^2 + 8.515690830166166s + 19.3914636736468)(1.0s - 0.5156908301661673)

Continuous-time transfer function model

Объединение входов и выходов

Вы можете объединить входные данные двух моделей H1 и H2, введя:

In [ ]: 
H = [H1 H2]
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Complex{Int64}}}
Input 1 to output 1
     1
2----------
 (s + 3)(s)

Input 2 to output 1
   1
5-----
 s + 5

Continuous-time transfer function model

Результирующая модель имеет два входа и один выход, что соответствует следующей схеме:

gsconnectingmodels_05.png

Аналогично, вы можете объединить выходные данные H1 и H2 , введя:

In [ ]: 
H = [ H1 ; H2 ]
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Complex{Int64}}}
Input 1 to output 1
     1
2----------
 (s + 3)(s)

Input 1 to output 2
   1
5-----
 s + 5

Continuous-time transfer function model

Результирующая модель H имеет два выхода и один вход и соответствует следующей блок-схеме:

gsconnectingmodels_06.png

Наконец, вы можете объединить входные и выходные данные двух моделей, используя:

In [ ]: 
H = append(H1,H2)
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Complex{Int64}}}
Input 1 to output 1
     1
2----------
 (s + 3)(s)

Input 1 to output 2
 1
0-
 1

Input 2 to output 1
 1
0-
 1

Input 2 to output 2
   1
5-----
 s + 5

Continuous-time transfer function model

Результирующая модель H имеет два входа и два выхода и соответствует структурной схеме: gsconnectingmodels_07.png

Вы можете использовать конкатенацию для построения моделей MIMO из элементарных моделей SISO, например:

In [ ]: 
[H1 -tf(10,[1, 10]); 0 H2]
Out[0]:
TransferFunction{Continuous, ControlSystemsBase.SisoZpk{Int64, Complex{Int64}}}
Input 1 to output 1
     1
2----------
 (s + 3)(s)

Input 1 to output 2
 1
0-
 1

Input 2 to output 1
     1
-10------
   s + 10

Input 2 to output 2
   1
5-----
 s + 5

Continuous-time transfer function model

Также вы можете воспользоваться функцией array2mimo. Например,

In [ ]: 
P = ss(-1,1,1,0);
sys_array = fill(P, 2, 2) # Создает массив систем
mimo_sys = array2mimo(sys_array)
Out[0]:
StateSpace{Continuous, Int64}
A = 
 -1   0   0   0
  0  -1   0   0
  0   0  -1   0
  0   0   0  -1
B = 
 1  0
 0  1
 1  0
 0  1
C = 
 1  1  0  0
 0  0  1  1
D = 
 0  0
 0  0

Continuous-time state-space model

Построение моделей на основе блок-схем

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

gsconnectingmodels_09.png со следующими данными для блоков F, C, G, S:

In [ ]: 
s = tf('s');
F = 1/(s + 1);
G = 100/(s^2 + 5*s + 100);
C = 20*(s^2 + s + 60)/s/(s^2 + 40*s + 400);
S = 10/(s + 10);

Вы можете определить передаточную функцию замкнутой системы из r в y следующим образом:

In [ ]: 
T = F * feedback(G*C,S)
plot(step(T,10))
Out[0]:

Но для более сложных блок-схем используйте функцию connect библиотеки RobustAndOptimalControl.jl. Чтобы использовать connect, выполните следующие действия:

  • Определите все блоки на схеме, включая блоки суммирования;
  • Назовите все каналы ввода и вывода блоков;
  • Сопоставьте выходы (output) блоков системы с соответствующими входами (input) блоков.

Рассмотрим пример использования функции на примере следующей структурной схемы. gsconnectingmodels_11.png

Импортируйте и подключите библиотеку RobustAndOptimalControl.jl.

In [ ]: 
import Pkg
Pkg.add("RobustAndOptimalControl")

   Resolving package versions...
  No Changes to `~/.project/Project.toml`
  No Changes to `~/.project/Manifest.toml`
In [ ]: 
using RobustAndOptimalControl

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

In [ ]: 
F1 = named_ss(F, x=:xF, u=:r, y=:u_f)
Out[0]:
NamedStateSpace{Continuous, Float64}
A = 
 -1.0
B = 
 1.0
C = 
 1.0
D = 
 0.0

Continuous-time state-space model
With state  names: xF
     input  names: r
     output names: u_f
In [ ]: 
G1 = named_ss(G, x=:xG, u=:u, y=:y_m)
Out[0]:
NamedStateSpace{Continuous, Float64}
A = 
  0.0   16.0
 -6.25  -5.0
B = 
 0.0
 2.0
C = 
 3.125  0.0
D = 
 0.0

Continuous-time state-space model
With state  names: xG1 xG2
     input  names: u
     output names: y_m
In [ ]: 
C1 = named_ss(C, x=:xC, u=:e, y=:u_c)
Out[0]:
NamedStateSpace{Continuous, Float64}
A = 
 0.0    4.0    0.0
 0.0    0.0   16.0
 0.0  -25.0  -40.0
B = 
 0.0
 0.0
 8.0
C = 
 2.34375  0.15625  2.5
D = 
 0.0

Continuous-time state-space model
With state  names: xC1 xC2 xC3
     input  names: e
     output names: u_c
In [ ]: 
S1 = named_ss(S, x=:xS, u=:y_m, y=:y)
Out[0]:
NamedStateSpace{Continuous, Float64}
A = 
 -10.0
B = 
 4.0
C = 
 2.5
D = 
 0.0

Continuous-time state-space model
With state  names: xS
     input  names: y_m
     output names: y

Обозначьте сумматоры, используя функцию sumblock.

In [ ]: 
Sum1 = sumblock("e = r - y")
Out[0]:
sumblock: NamedStateSpace{Continuous, Float64}
D = 
 1.0  -1.0

Continuous-time state-space model
With state  names: 
     input  names: r y
     output names: e
In [ ]: 
Sum2 = sumblock("u = u_f + u_c")
Out[0]:
sumblock: NamedStateSpace{Continuous, Float64}
D = 
 1.0  1.0

Continuous-time state-space model
With state  names: 
     input  names: u_f u_c
     output names: u

Важно внимательно обозначить соединения. Соединения образуются по принципы выход одного блока присоединяется ко входу другого. Например, сигнал е является выходом Sum1, но при этом является входом для блока C.

In [ ]: 
connections = [
    :e => :e # output e Sum1 to input C
    :y => :y # output y S to input Sum1
    :u => :u # output u Sum2 to input G
    :u_f => :u_f # output u_f F to input Sum2
    :u_c => :u_c # output u_c C to input Sum2
    :y_m => :y_m # output G to input S
]
Out[0]:
6-element Vector{Pair{Symbol, Symbol}}:
   :e => :e
   :y => :y
   :u => :u
 :u_f => :u_f
 :u_c => :u_c
 :y_m => :y_m

Также важно определить входной сигнал w1 и выходной z1.

In [ ]: 
w1 = [:r]
z1 = [:y_m]
Out[0]:
1-element Vector{Symbol}:
 :y_m

Все рассчитанные данные подаем на вход connect. Подробнее изучить все параметры функции можно в документации Julia Объединение систем.

In [ ]: 
P = connect([F1, C1, G1, S1, Sum1, Sum2], connections; w1,z1,unique = false)
Out[0]:
NamedStateSpace{Continuous, Float64}
A = 
 -1.0  0.0       0.0       0.0   0.0    0.0    0.0
  0.0  0.0       4.0       0.0   0.0    0.0    0.0
  0.0  0.0       0.0      16.0   0.0    0.0    0.0
  0.0  0.0     -25.0     -40.0   0.0    0.0  -20.0
  0.0  0.0       0.0       0.0   0.0   16.0    0.0
  2.0  4.6875    0.3125    5.0  -6.25  -5.0    0.0
  0.0  0.0       0.0       0.0  12.5    0.0  -10.0
B = 
 1.0
 0.0
 0.0
 8.0
 0.0
 0.0
 0.0
C = 
 0.0  0.0  0.0  0.0  3.125  0.0  0.0
D = 
 0.0

Continuous-time state-space model
With state  names: xF##feedback#587 xC1##feedback#587 xC2##feedback#587 xC3##feedback#587 xG1##feedback#587 xG2##feedback#587 xS##feedback#587
     input  names: r
     output names: y_m

Построим переходный процесс полученной замкнутой системы.

In [ ]: 
plot(stepinfo(step(P,5)))
Out[0]:

Заключение

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