From Block Diagrams to Code

Block diagrams are modular and allow for relatively easy manipulation of system functionals; by noticing certain patterns (such as the cascade, feedback addition, and feedforward addition discussed in lecture), we can convert a block diagram to a system functional. Our simulation framework will mimic block diagrams, and we will implement these patterns as our means of combination (with Gains and Delays as our primitives), so that finding a system's system functional programmatically is only a matter of recognizing these patterns (and we can leave the algebra to the computer!).

1) Example: Simulating Gain

The power of the framework this page details is in simulating large systems. The algebraic tedium can be done by a computer. However, to get a sense how how to use this framework, we will begin with a very simple example, simulating the following system:

We can create a gain block with an instance of the Gain class, whose initializer takes as its sole argument a number representing the value k of the gain block:

g = Gain(k)

Now the variable g is storing our model of the above block diagram. This is similar to manually writing out the difference equation coeficients.

To simulate this system, first we construct a simulator

g_sim = SystemSimulator(g)

Next we can run this simulator given some input.

g_in = [1] + [0]*9 # equivalent to [1,0,0,0,0,0,0,0,0]
g_out = g_sim.get_response(g_in)

g_out now stores a list of samples of the output of the system g given the input g_in This evalutes to

[k,0,0,0,0,0,0,0,0]

2) Primitives

Our primitives include gains and delays.

2.1) Gain

You can represent a gain block with an instance of the Gain class, whose initializer takes as its sole argument a number representing the value k of the gain block:

g = Gain(k)

2.2) Delay (R)

We can also represent delays with instances of the R class, whose initializer takes a single argument representing its output on the 0^th timestep (note that, after the first timestep, its output at time n will be its input from time n-1):

r = R(initial_output)

3) Combinations

We can combine systems together using the following classes, representing the various patterns that were discussed in lecture:

3.1) Cascade

c = Cascade(s1, s2)

3.2) Feedforward Addition

f = FeedforwardAdd(s1, s2)

3.3) Feedback Addition

f = FeedbackAdd(s1, s2)

4) Simulating

Once the model has been constructed, you may want to simulate it to see how it responds to various inputs. You can create a simulator from one of these models by constructing a SystemSimulator from the model. The resulting SystemSimulator has a method called get_response that can compute the system's response to provided input.

5) Example

For example, consider the Fibonacci's Bunnies system from lecture 2:

We can model this system (when started from rest) with the following code:

upper_subsystem = FeedbackAdd(Gain(1), R(0))
lower_subsystem = Cascade(R(0), R(0))
bunnies_model = FeedbackAdd(upper_subsystem, lower_subsystem)

This creates a model of the system, which mimics the structure of the block diagram. To compute the unit sample response of this system, we could use the following code, which constructs a simulator to simulate our model:

bunnies_sim = SystemSimulator(bunnies_model)
bunnies_usr = bunnies_sim.get_response([1] + [0]*9)