Discrete state-space in Simulink - Step-by-Step Execution

Concept Flow - Discrete state-space

Input u(k)

↓

State Update: x(k+1) = A*x(k) + B*u(k)

↓

Output Calculation: y(k) = C*x(k) + D*u(k)

↓

Next Step: k = k + 1

↩Back to State Update

The discrete state-space model updates the system state and output at each time step using matrices A, B, C, D with input u(k) and current state x(k).

Execution Sample

Simulink

x_next = A @ x + B @ u
 y = C @ x + D @ u

Calculate next state and output from current state and input using matrix multiplication.

Execution Table

Step	k	x(k)	u(k)	x(k+1) = A*x(k)+B*u(k)	y(k) = C*x(k)+D*u(k)
1	0	[0; 0]	[1]	[0.5; 0.2]	[0.1]
2	1	[0.5; 0.2]	[0]	[0.25; 0.1]	[0.05]
3	2	[0.25; 0.1]	[1]	[0.625; 0.3]	[0.125]
4	3	[0.625; 0.3]	[0]	[0.3125; 0.15]	[0.0625]
5	4	[0.3125; 0.15]	[1]	[0.78125; 0.35]	[0.15625]
Exit	5	N/A	N/A	Simulation ends at step 5	N/A

💡 Simulation stops after 5 steps as defined.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
x(k)	[0; 0]	[0.5; 0.2]	[0.25; 0.1]	[0.625; 0.3]	[0.3125; 0.15]	N/A
u(k)	[1]	[0]	[1]	[0]	[1]	N/A
y(k)	N/A	[0.1]	[0.05]	[0.125]	[0.0625]	N/A

Key Moments - 2 Insights

Why does the state x(k) change at each step even if input u(k) is zero sometimes?

Because the next state x(k+1) depends on both the current state x(k) and input u(k). Even if u(k) is zero, the matrix A times x(k) can change the state, as shown in rows 2 and 4 of the execution_table.

Why do we calculate output y(k) using both x(k) and u(k)?

Output y(k) depends on the current state and input through matrices C and D. This means output reflects system state and immediate input, as seen in the formula and execution_table columns.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of x(k+1)?

A [0.625; 0.3]

B [0.25; 0.1]

C [0.3125; 0.15]

D [0.5; 0.2]

💡 Hint

Check the 'x(k+1)' column at step 3 in the execution_table.

At which step does the input u(k) equal zero for the first time?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'u(k)' column in the variable_tracker or execution_table.

If input u(k) was always 1, how would y(k) change compared to the current table?

A y(k) would be smaller at each step

B y(k) would be zero

C y(k) would be larger at each step

D y(k) would not change

💡 Hint

Since y(k) depends on u(k) through matrix D, increasing u(k) increases y(k).

Concept Snapshot

Discrete State-Space Model:
- State update: x(k+1) = A*x(k) + B*u(k)
- Output: y(k) = C*x(k) + D*u(k)
- Works step-by-step for discrete time k
- Uses matrices A,B,C,D and vectors x,u,y
- Captures system dynamics in matrix form

Full Transcript

In a discrete state-space model, the system state x and output y update at each time step k. The next state x(k+1) is calculated by multiplying the current state x(k) by matrix A and adding the input u(k) multiplied by matrix B. The output y(k) is calculated by multiplying the current state x(k) by matrix C and adding the input u(k) multiplied by matrix D. This process repeats for each time step, showing how the system evolves over time. The execution table traces these calculations step-by-step, showing how x and y change with different inputs. Key points include understanding that the state changes even if input is zero because of matrix A, and output depends on both state and input. The quiz questions help check understanding of these steps.

Practice

1. What does a discrete state-space model in Simulink primarily represent?

easy

A. A continuous-time system with differential equations

B. A graphical user interface for designing circuits

C. A system described by matrices that updates states step-by-step

D. A tool for creating 3D animations

Solution

1. Step 1: Understand discrete state-space concept

   Discrete state-space models describe systems using matrices that update the system's state at each time step.

2. Step 2: Compare options

   Only a system described by matrices that updates states step-by-step correctly describes this concept; others describe unrelated tools or continuous systems.

3. Final Answer:

   A system described by matrices that updates states step-by-step -> Option C

4. Quick Check:

   Discrete state-space = step-by-step matrix system [OK]

Hint: Discrete means step-by-step matrix updates [OK]

Common Mistakes:

• Confusing discrete with continuous systems
• Thinking state-space is only for continuous models
• Mixing up state-space with graphical tools

2. Which of the following is the correct syntax to define a discrete state-space system in Simulink's MATLAB Function block?

easy

A. sys = ss(A, B, C, D);

B. sys = ss(A, B, C, D, Ts);

C. sys = discrete(A, B, C, D, Ts);

D. sys = state_space(A, B, C, D, Ts);

Solution

1. Step 1: Recall syntax for discrete state-space

   In MATLAB/Simulink, discrete state-space systems use ss(A,B,C,D,Ts) where Ts is the sample time.

2. Step 2: Evaluate options

   sys = ss(A, B, C, D, Ts); matches the correct syntax. sys = ss(A, B, C, D); misses Ts (sample time), C and D use incorrect function names.

3. Final Answer:

   sys = ss(A, B, C, D, Ts); -> Option B

4. Quick Check:

   Discrete ss needs sample time Ts [OK]

Hint: Discrete ss needs sample time Ts as last argument [OK]

Common Mistakes:

• Omitting the sample time Ts
• Using wrong function names like discrete()
• Confusing continuous and discrete syntax

3. Given the discrete state-space matrices:
A = [[0.7, 0.2], [0, 0.9]];
B = [[0.1], [0.05]];
and initial state x0 = [1; 0], what is the state x[1] after one step with input u[0] = 2?

medium

A. [1.6; 0.1]

B. [1.0; 0.05]

C. [1.8; 0.0]

D. [0.9; 0.1]

Solution

1. Step 1: Calculate next state using formula

   Next state x[1] = A * x0 + B * u[0]. Calculate:
   A * x0 = [0.7*1 + 0.2*0; 0*1 + 0.9*0] = [0.7; 0]
   B * u[0] = [0.1*2; 0.05*2] = [0.2; 0.1]

2. Step 2: Add results to get x[1]

   x[1] = [0.7; 0] + [0.2; 0.1] = [0.9; 0.1]

3. Final Answer:

   [0.9; 0.1] -> Option D

4. Quick Check:

   Use x[1] = A*x0 + B*u[0] [OK]

Hint: Multiply A*x0 and add B*u[0] for next state [OK]

Common Mistakes:

• Forgetting to multiply input u by B
• Mixing matrix multiplication order
• Adding instead of multiplying matrices

4. You have this discrete state-space model in Simulink:
A = [[1, 0], [0, 1]];
B = [[0], [0]];
C = [[1, 0]];
D = [[0]];
Why does the output never change regardless of input?

medium

A. Because matrix B is zero, input has no effect on state

B. Because matrix C is zero, output is always zero

C. Because matrix A is identity, states never update

D. Because matrix D is zero, output ignores input

Solution

1. Step 1: Analyze matrix B effect on input

   Matrix B is zero, so input u does not affect state update: x[k+1] = A*x[k] + B*u[k] = A*x[k].

2. Step 2: Understand output behavior

   Output y = C*x + D*u depends only on state x and input u. Since input doesn't change state, output depends only on initial state and does not change with input.

3. Final Answer:

   Because matrix B is zero, input has no effect on state -> Option A

4. Quick Check:

   Zero B means input can't change state [OK]

Hint: Zero B means input can't change state [OK]

Common Mistakes:

• Confusing zero D with zero B effect
• Assuming identity A means output changes
• Ignoring input effect on state update

5. You want to design a discrete state-space model in Simulink to simulate a system with states updated every 0.1 seconds. The system matrices are:
A = [[0.8, 0.1], [0, 0.9]];
B = [[0.05], [0.02]];
Which sample time should you specify to correctly model this system?

hard

A. 0.1

B. 1

C. 0

D. -0.1

Solution

1. Step 1: Understand sample time meaning

   Sample time Ts defines how often the discrete system updates its state. Here, states update every 0.1 seconds.

2. Step 2: Choose correct sample time

   Ts must be positive and equal to the update interval, so Ts = 0.1 seconds.

3. Final Answer:

   0.1 -> Option A

4. Quick Check:

   Sample time = update interval = 0.1 [OK]

Hint: Sample time equals system update interval (positive) [OK]

Common Mistakes:

• Using zero or negative sample time
• Confusing sample time with continuous time
• Choosing wrong units for sample time