Overview
Comment:Compatible with Octave 2.1.57
Downloads: Tarball | ZIP archive
Timelines: family | ancestors | descendants | both | origin/master | trunk
Files: files | file ages | folders
SHA3-256: d2263a71365866f1ae2fd4621c836195a92f2c583cf4c7898d446b33a84089b4
User & Date: gawthrop@users.sourceforge.net on 2004-08-09 14:44:41.000
Other Links: branch diff | manifest | tags
Context
2004-08-09
14:47:28
Changed arg to args to avoid strange octave bug check-in: d0b97fa131 user: gawthrop@users.sourceforge.net tags: origin/master, trunk
14:44:41
Compatible with Octave 2.1.57 check-in: d2263a7136 user: gawthrop@users.sourceforge.net tags: origin/master, trunk
2004-08-05
09:07:51
Sorts by type:name within categories: ports, components, 0, 1 check-in: 5e3a150ae1 user: geraint@users.sourceforge.net tags: origin/master, trunk
Changes
Side-by-Side Diff Ignore Whitespace Patch
Modified mttroot/mtt/lib/control/PPP/ppp_ex15.m from [d1ae59f7c7] to [f570a84dcf].
︙
38
39
40
41
42
43
44

45

46
47
48
49
50
51
52

38
39
40
41
42
43
44
45

46
47
48
49
50
51
52
53








+
-
+








  x_0 = zeros(n_x,1);		# Initial state


  ## Closed-loop intermittent solution
  Delta_ol = 0.5		# Intermittent time

  disp("Intermittent control simulation");
  R=1;P=0;
  [T,y,u] = ppp_qp_sim (A,B,C,D,A_u,A_w,t,Q, \
  [T,y,u] = ppp_qp_sim (A,B,C,D,A_u,A_w,t,Q,R,P, \
			  [],[],[],[], \
			  [],[],[],[],W,x_0,Delta_ol);
size(T)
  ## Exact closed-loop
  disp("Exact closed-loop");
  [k_x,k_w] = ppp_lin (A,B,C,D,A_u,A_w,t,Q)
  [ye,Xe] = ppp_sm2sr(A-B*k_x, B, C, D, T, k_w*W, x_0); # Compute Closed-loop control
︙
Modified mttroot/mtt/lib/control/PPP/ppp_inflate.m from [7743bb793c] to [c4fc3a116e].
︙
11
12
13
14
15
16
17
18

19
20
21
22
23
24
25

11
12
13
14
15
16
17

18
19
20
21
22
23
24
25








-
+









  if N<M
    error("A_v must have at least as many rows as columns");
  endif
  
  n = N/M;			# Number of matrix elements in A_v

  if round(n)<>n
  if round(n)!=n
    error("A_v must be a column vector of square matrices");
  endif
  
  A_m = [];
  for i = 1:n
    A_m = ppp_aug(A_m,ppp_extract(A_v,i));
  endfor
︙
Modified mttroot/mtt/lib/control/PPP/ppp_lin.m from [4162496ee0] to [2f56086151].
︙
165
166
167
168
169
170
171
172


173
174
175
176
177
178
179

165
166
167
168
169
170
171

172
173
174
175
176
177
178
179
180








-
+
+








    J_ux = J_ux + (QQ .* y_u(:,i:n_y:n_yu)') * y_x(:,i:n_y:n_yx);
    QQ = ones(n_x,1)*Q(i,:);	# Resize Q
    J_xx = J_xx + (QQ .* y_x(:,i:n_y:n_yx)') * y_x(:,i:n_y:n_yx);
  endfor

  ## Input weighting (scalar for the moment)
  if (n_u>1)
    warning("Sorry, cant do n_u>1 just now");
    warning("Sorry, cant do n_u>1 just now: exiting");
    return
  endif

  ## Scale R
  R = R*dt;			# Scale to give correct units
  for i = 1:m_t
    Ust = Us(i,:);
    J_uu = J_uu + Ust'*R*Ust;
︙
Modified mttroot/mtt/lib/control/PPP/ppp_lin_quad.m from [b791777adb] to [56182147a4]. 
1
2

3
4
5

6
7
8
9
10





11


12
13
14
15
16
17
18

1

2
3
4

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


-
+


-
+





+
+
+
+
+

+
+








function [k_x,k_w,K_x,K_w,Us0,J_uu,J_ux,J_uw,J_xx,J_xw,J_ww,A_u] = \
      ppp_lin_quad (A,B,C,D,tau,Q,R)
      ppp_lin_quad (A,B,C,D,tau,Q,R,A_e)

  ## usage:[k_x,k_w,K_x,K_w,Us0,J_uu,J_ux,J_uw,J_xx,J_xw,J_ww,A_u] =
  ## ppp_lin_quad (A,B,C,D,tau,Q,R)
  ## ppp_lin_quad (A,B,C,D,tau,Q,R[,A_e])
  ##
  ## 

  ## Steady-state Linear Quadratic solution
  ## using Algebraic Riccati equation (ARE)

  if nargin<8
    A_e = [];
  endif
  
  [P,A_u,A_w] = ppp_are (A,B,C,D,Q,R);

  A_u = ppp_aug(A_u,A_e);

  ## PPP solution
  [k_x,k_w,K_x,K_w,Us0,J_uu,J_ux,J_uw,J_xx,J_xw,J_ww] = \
      ppp_lin(A,B,C,D,A_u,A_w,tau,Q,R,P);


endfunction
Modified mttroot/mtt/lib/control/PPP/ppp_open2closed.m from [f6b3aefde7] to [06ac18219c].
︙
14
15
16
17
18
19
20
21

22
23
24
25
26
27
28

14
15
16
17
18
19
20

21
22
23
24
25
26
27
28








-
+








  ## 	$Id$	


  ## Check sizes
  n_o = is_square(A_u);
  n_c = is_square(A_c);

  if (n_o==0)||(n_c==0)||(n_o<>n_c)
  if (n_o==0)||(n_c==0)||(n_o!=n_c)
    error("A_u and A_c must be square and of the same dimension");
  endif

  [n_u,n_x] = size(k_x);

  ## Defaults
  if nargin<4
︙
Modified mttroot/mtt/lib/control/PPP/ppp_qp_sim.m from [3bd70b9dea] to [6333ae0d35].
︙
60
61
62
63
64
65
66
67
68


69
70
71
72
73
74
75

60
61
62
63
64
65
66


67
68
69
70
71
72
73
74
75








-
-
+
+








  if Delta_ol>0			# Intermittent control
    T_ol = 0:dt:Delta_ol;	# Create the open-loop time vector
  else
    T_ol = [0,dt];
    Delta_ol = dt;
  endif
  t_last = t(length(t));
  T_cl = 0:Delta_ol:t_last-Delta_ol; # Closed-loop time vector
  T = 0:dt:t_last;		# Overall time vector
  T_cl = 0:Delta_ol:2*t_last-Delta_ol; # Closed-loop time vector
  T = 0:dt:2*t_last;		# Overall time vector
 
  ## Lengths thereof
  n_Tcl = length(T_cl);
  n_ol = length(T_ol);
  n_T = length(T);

  ## Expand W with constant last value or truncate
︙
100
101
102
103
104
105
106
107

108
109
110
111
112
113
114

100
101
102
103
104
105
106

107
108
109
110
111
112
113
114








-
+








  Iterations = [];
  du = [];
  J = [];
  tick= time;

  ## disp("Simulating ...");
  for t=T_cl			# Outer loop at Delta_ol

    printf("%g\r",t);
    ##disp(sprintf("Time %g", t));
    ## Output constraints
    [Gamma_y,gamma_y] = ppp_output_constraints  (A,B,C,D,x,A_u,Tau_y,Min_y,Max_y,Order_y);
    
    ## Composite constraints 
    Gamma = [Gamma_u; Gamma_y];
    gamma = [gamma_u; gamma_y];
︙
Modified mttroot/mtt/lib/control/PPP/ppp_ystar.m from [34d0435ae4] to [17c1b7c256].
︙
20
21
22
23
24
25
26
27
28








29
30
31
32
33
34
35

20
21
22
23
24
25
26


27
28
29
30
31
32
33
34
35
36
37
38
39
40
41








-
-
+
+
+
+
+
+
+
+








  ## xs          x*, one column for each time tau 
  ## xu          x_u, one column for each time tau 
  ## AA          The composite system matrix
  
  ## Copyright (C) 1999 by Peter J. Gawthrop
  ## 	$Id$	


  [n_x,n_u,n_y] = abcddim(A,B,C,D); # System dimensions
  if (size(A)>0)
    [n_x,n_u,n_y] = abcddim(A,B,C,D); # System dimensions
  else
    n_x = 0;
    n_y = 0;
    n_u = 0;
  endif
  
  no_system = n_x==0;

  [n,m] = size(A_u);		# Size of composite A_u matrix
  square = (n==m);		# Is A_u square?
  n_U = m;			# functions per input
︙
113
114
115
116
117
118
119

120





121
122
123
124
125
126
127
128
129

119
120
121
122
123
124
125
126

127
128
129
130
131
132
133
134
135
136
137
138
139
140








+
-
+
+
+
+
+










  n_xx = length(xx_0);		# Length of composite state

  ## Compute the star variables
  for t=tau
    xxt = expm(AA*t)*xx_0;	# Composite state
    xst = xxt(1:n_x);		# x star
    xut = xxt(n_x+1:n_xx);	# x star
    if length(C)>0
    yst = C*xst;		# y star
      yst = C*xst;		# y star
    else
      yst = [];
    endif
    
    ust = Utilde*xut;		# u star

    xs = [xs xst];		# x star
    xu = [xu xut];		# x star
    ys = [ys yst];		# y star
    us = [us ust];		# u star
  endfor

endfunction
MTT: Model Transformation Tools
[ GitHub | SourceHut | Sourceforge | Fossil RSS ]