pySimBlocks 0.1.0__py3-none-any.whl

examples/basics/dc_motor/pi.py

@@ -0,0 +1,99 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import Sum, Gain, DiscreteIntegrator
+
+
+def manual(A, B, C, Kp, Ki, dt, T):
+    ref = Step("ref", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+    kp = Gain("Kp", Kp)
+    ki = Gain("Ki", Ki)
+    integrator = DiscreteIntegrator("integrator")
+    sum = Sum("sum", "++")
+
+    blocks = [ref, error, kp, integrator, ki, sum, motor]
+
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "Kp", "in")
+    model.connect("error", "out", "Ki", "in")
+    model.connect("Kp", "out", "sum", "in1")
+    model.connect("Ki", "out", "integrator", "in")
+    model.connect("integrator", "out", "sum", "in2")
+    model.connect("sum", "out", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run(logging=[
+            "ref.outputs.out",
+                "motor.outputs.y",
+                "sum.outputs.out",
+                "integrator.outputs.out",
+                "Kp.outputs.out"
+            ])
+
+
+    time = sim.get_data("time")
+    r = sim.get_data("ref.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    u = sim.get_data("sum.outputs.out").squeeze()
+    p_term = sim.get_data("Kp.outputs.out").squeeze()
+    i_term = sim.get_data("integrator.outputs.out").squeeze()
+
+    return time, r, w, u, p_term, i_term
+
+def main():
+    # DC Motor parameters
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    Kp = np.array([[0.001]])
+    Ki = np.array([[0.02]])
+
+    # Simulation parameters
+    dt = 0.01
+    T = 100.
+
+    # State-space matrices
+    A = np.array([[1-dt*R/L, -dt*K/L], [dt*K/J, 1-dt*a/J]])
+    B = np.array([[dt/L], [0]])
+    C = np.array([[0, 1]])
+
+
+    time_man, r_man, w_man, u_man, p_term, i_term = manual(A, B, C, Kp, Ki, dt, T)
+
+
+    plt.figure()
+    plt.step(time_man, r_man, ':r', label="Reference (Manual)", where='post')
+    plt.step(time_man, w_man, ':b', label="Motor Speed (Manual)", where='post')
+    plt.step(time_man, u_man, ':g', label="Control Input (Manual)", where='post')
+    plt.xlabel("Time (s)")
+    plt.ylabel("Speed (rad/s)")
+    plt.title("DC Motor PI Speed Response")
+    plt.legend()
+    plt.grid()
+
+    plt.figure()
+    plt.step(time_man, p_term, '-r', label="P Term", where='post')
+    plt.step(time_man, i_term, '-g', label="I Term", where='post')
+    plt.xlabel("Time (s)")
+    plt.ylabel("Term Value")
+    plt.title("PID Controller Terms (Manual Implementation)")
+    plt.legend()
+    plt.grid()
+
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/basics/dc_motor/pid.py

@@ -0,0 +1,118 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import (
+    Sum,
+    Gain,
+    DiscreteIntegrator,
+    DiscreteDerivator,
+)
+
+
+def manual(A, B, C, Kp, Ki, Kd, dt, T):
+    ref = Step("ref", start_time=1.0, value_before=0.0, value_after=1.0)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+    kp = Gain("Kp", Kp)
+    ki = Gain("Ki", Ki)
+    integrator = DiscreteIntegrator("integrator")
+    kd = Gain("Kd", Kd)
+    derivator = DiscreteDerivator("derivator")
+    sum = Sum("sum", "+++")
+
+    blocks = [ref, error, kp, integrator, ki, sum, motor, kd, derivator]
+
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "Kp", "in")
+    model.connect("error", "out", "Ki", "in")
+    model.connect("error", "out", "Kd", "in")
+    model.connect("Kp", "out", "sum", "in1")
+    model.connect("Ki", "out", "integrator", "in")
+    model.connect("integrator", "out", "sum", "in3")
+    model.connect("Kd", "out", "derivator", "in")
+    model.connect("derivator", "out", "sum", "in2")
+    model.connect("sum", "out", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=False)
+
+    logs = sim.run(
+        logging=[
+            "ref.outputs.out",
+            "motor.outputs.y",
+            "sum.outputs.out",
+            "derivator.outputs.out",
+            "integrator.outputs.out",
+            "Kp.outputs.out",
+        ]
+    )
+
+    time = sim.get_data("time")
+    r = sim.get_data("ref.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    u = sim.get_data("sum.outputs.out").squeeze()
+    
+    p_term = sim.get_data("Kp.outputs.out").squeeze()
+    i_term = sim.get_data("integrator.outputs.out").squeeze()
+    d_term = sim.get_data("derivator.outputs.out").squeeze()
+
+    return time, r, w, u, p_term, i_term, d_term
+
+
+def main():
+    # DC Motor parameters
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    Kp = np.array([[0.001]])
+    Ki = np.array([[0.02]])
+    Kd = np.array([[0.01]])
+
+    # Simulation parameters
+    dt = 0.01
+    T = 100.0
+
+    # State-space matrices
+    A = np.array([[1 - dt * R / L, -dt * K / L], [dt * K / J, 1 - dt * a / J]])
+    B = np.array([[dt / L], [0]])
+    C = np.array([[0, 1]])
+
+    time_man, r_man, w_man, u_man, p_term, i_term, d_term = manual(
+        A, B, C, Kp, Ki, Kd, dt, T
+    )
+
+    plt.figure()
+    plt.step(time_man, r_man, ":r", label="Reference (Manual)", where="post")
+    plt.step(time_man, w_man, ":b", label="Motor Speed (Manual)", where="post")
+    plt.step(time_man, u_man, ":g", label="Control Input (Manual)", where="post")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Speed (rad/s)")
+    plt.title("DC Motor PID Speed Response")
+    plt.legend()
+    plt.grid()
+
+    plt.figure()
+    plt.step(time_man, p_term, "-r", label="P Term", where="post")
+    plt.step(time_man, i_term, "-g", label="I Term", where="post")
+    plt.step(time_man, d_term, "-b", label="D Term", where="post")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Term Value")
+    plt.title("PID Controller Terms (Manual Implementation)")
+    plt.legend()
+    plt.grid()
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

examples/basics/dc_motor/pid_block.py

@@ -0,0 +1,82 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import Sum
+from pySimBlocks.blocks.controllers import Pid
+
+
+def pid(A, B, C, Kp, Ki, Kd, dt, T):
+    ref = Step("ref", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+    pid = Pid("pid", Kp=Kp, Ki=Ki, Kd=Kd)
+
+    blocks = [ref, error, pid, motor]
+
+    # Model
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "pid", "e")
+    model.connect("pid", "u", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=False)
+
+    logs = sim.run(logging=[
+            "ref.outputs.out",
+            "motor.outputs.y",
+            "pid.outputs.u"
+        ])
+
+    time = sim.get_data("time")
+    r = sim.get_data("ref.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    u = sim.get_data("pid.outputs.u").squeeze()
+
+    return time, r, w, u
+
+
+def main():
+    # DC Motor parameters
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    Kp = 0.001
+    Ki = 0.02
+    Kd = 0.01
+
+    # Simulation parameters
+    dt = 0.01
+    T = 100.
+
+    # State-space matrices
+    A = np.array([[1-dt*R/L, -dt*K/L], [dt*K/J, 1-dt*a/J]])
+    B = np.array([[dt/L], [0]])
+    C = np.array([[0, 1]])
+
+
+    time_pid, r_pid, w_pid, u_pid = pid(A, B, C, Kp, Ki, Kd, dt, T)
+
+
+    plt.figure()
+    plt.step(time_pid, r_pid, '--r', label="Reference (PID)", where='post')
+    plt.step(time_pid, w_pid, '--b', label="Motor Speed (PID)", where='post')
+    plt.step(time_pid, u_pid, '--g', label="Control Input (PID)", where='post')
+    plt.xlabel("Time (s)")
+    plt.ylabel("Speed (rad/s)")
+    plt.title("DC Motor Speed Response")
+    plt.legend()
+    plt.grid()
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/basics/dc_motor/pid_block_vs_manual.py

@@ -0,0 +1,143 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Step
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.operators import Sum, Gain, DiscreteIntegrator, DiscreteDerivator
+from pySimBlocks.blocks.controllers import Pid
+
+
+def pid(A, B, C, Kp, Ki, Kd, dt, T):
+    ref = Step("ref", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+    pid = Pid("pid", Kp=Kp, Ki=Ki, Kd=Kd)
+
+    blocks = [ref, error, pid, motor]
+
+# Model
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "pid", "e")
+    model.connect("pid", "u", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run(logging=[
+            "ref.outputs.out",
+            "motor.outputs.y",
+            "pid.outputs.u"
+        ])
+
+    time = sim.get_data("time")
+    r = sim.get_data("ref.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    u = sim.get_data("pid.outputs.u").squeeze()
+
+    return time, r, w, u
+
+def manual(A, B, C, Kp, Ki, Kd, dt, T):
+    ref = Step("ref", start_time=1., value_before=0., value_after=1.)
+    motor = LinearStateSpace("motor", A, B, C)
+    error = Sum("error", signs="+-")
+    kp = Gain("Kp", Kp)
+    ki = Gain("Ki", Ki)
+    integrator = DiscreteIntegrator("integrator")
+    kd = Gain("Kd", Kd)
+    derivator = DiscreteDerivator("derivator")
+    sum = Sum("sum", "+++")
+
+    blocks = [ref, error, kp, integrator, ki, sum, motor, kd, derivator]
+
+    model = Model("DC Motor Control")
+    for block in blocks:
+        model.add_block(block)
+    model.connect("ref", "out", "error", "in1")
+    model.connect("motor", "y", "error", "in2")
+    model.connect("error", "out", "Kp", "in")
+    model.connect("error", "out", "Ki", "in")
+    model.connect("error", "out", "Kd", "in")
+    model.connect("Kp", "out", "sum", "in1")
+    model.connect("Ki", "out", "integrator", "in")
+    model.connect("integrator", "out", "sum", "in3")
+    model.connect("Kd", "out", "derivator", "in")
+    model.connect("derivator", "out", "sum", "in2")
+    model.connect("sum", "out", "motor", "u")
+
+    # Simulator
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg, verbose=False)
+    logs = sim.run(logging=[
+            "ref.outputs.out",
+            "motor.outputs.y",
+            "sum.outputs.out",
+            "derivator.outputs.out",
+            "integrator.outputs.out",
+            "Kp.outputs.out"
+            ])
+
+    time = sim.get_data("time")
+    r = sim.get_data("ref.outputs.out").squeeze()
+    w = sim.get_data("motor.outputs.y").squeeze()
+    u = sim.get_data("sum.outputs.out").squeeze()
+
+    return time, r, w, u
+
+def main():
+    # DC Motor parameters
+    R = 0.1
+    L = 0.5
+    J = 0.01
+    K = 0.1
+    a = 0.001
+
+    Kp = np.array([[0.001]])
+    Ki = np.array([[0.02]])
+    Kd = np.array([[0.01]])
+
+    # Simulation parameters
+    dt = 0.01
+    T = 30.
+
+    # State-space matrices
+    A = np.array([[1-dt*R/L, -dt*K/L], [dt*K/J, 1-dt*a/J]])
+    B = np.array([[dt/L], [0]])
+    C = np.array([[0, 1]])
+
+
+    time_pid, r_pid, w_pid, u_pid = pid(A, B, C, Kp, Ki, Kd, dt, T)
+    time_man, r_man, w_man, u_man = manual(A, B, C, Kp, Ki, Kd, dt, T)
+
+    error = np.linalg.norm(w_pid - w_man)
+    print(f"Error between PID block and manual implementation: {error:.6f}")
+    print("Mean Error: ", np.mean(np.abs(w_pid - w_man)))
+
+    print("Time: ", time_pid[98:105].flatten())
+    print("PID w: ", w_pid[98:105].flatten())
+    print("Man w: ", w_man[98:105].flatten())
+    print("PID u: ", u_pid[98:105].flatten())
+    print("Man u: ", u_man[98:105].flatten())
+
+    plt.figure()
+    plt.step(time_pid, r_pid, '--r', label="Reference (PID)", where='post')
+    plt.step(time_pid, w_pid, '--b', label="Motor Speed (PID)", where='post')
+    plt.step(time_man, r_man, ':r', label="Reference (Manual)", where='post')
+    plt.step(time_man, w_man, ':b', label="Motor Speed (Manual)", where='post')
+    plt.xlabel("Time (s)")
+    plt.ylabel("Speed (rad/s)")
+    plt.title("DC Motor Speed Response")
+    plt.legend()
+    plt.grid()
+
+
+    plt.figure()
+    plt.step(time_pid, u_pid, '--g', label="Control Input (PID)", where='post')
+    plt.step(time_man, u_man, ':g', label="Control Input (Manual)", where='post')
+    plt.show()
+
+if __name__ == "__main__":
+    main()

examples/basics/external/parameters.py

@@ -0,0 +1,4 @@
+import numpy as np
+
+Kp = np.array([[2.]])
+Ki = np.array([[1.]])

examples/basics/external/run.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from pySimBlocks.project import load_simulator_from_project
+from pySimBlocks.project.plot_from_config import plot_from_config
+
+try:
+    BASE_DIR = Path(__file__).parent.resolve()
+except Exception:
+    BASE_DIR = Path("")
+
+sim, plot_cfg = load_simulator_from_project(BASE_DIR / "project.yaml")
+
+logs = sim.run()
+if True and plot_cfg is not None:
+    plot_from_config(logs, plot_cfg)

examples/basics/file_sources/temp.py

@@ -0,0 +1,16 @@
+import csv
+import numpy as np
+
+t = np.arange(0, 10, 0.1)
+y = np.sin(t)
+y = y.reshape(-1, 1)
+
+np.savez('data.npz', time=t, y=y)
+
+np.save('data.npy', y)
+
+with open('data.csv', 'w', newline='') as csvfile:
+    writer = csv.writer(csvfile)
+    writer.writerow(['time', 'y'])  # Write header
+    for t_val, y_val in zip(t, y):
+        writer.writerow([t_val, y_val[0]])  # Write each row of data

examples/basics/observer.py

@@ -0,0 +1,76 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import Constant
+from pySimBlocks.blocks.systems import LinearStateSpace
+from pySimBlocks.blocks.observers import Luenberger
+
+
+def main():
+    # System
+    A = np.array([[0.9]])
+    B = np.array([[1.0]])
+    C = np.array([[1.0]])
+
+    # Observer gain L
+    L = np.array([[0.5]])
+
+    # True plant
+    plant = LinearStateSpace("plant", A=A, B=B, C=C, x0=np.array([[0.0]]))
+
+    # Command (constant)
+    u_val = np.array([[1.0]])
+    u_src = Constant("u", value=u_val)
+
+    # Observer
+    obs = Luenberger(
+        name="observer",
+        A=A, B=B, C=C, L=L,
+        x0=np.array([[-2.0]])
+    )
+
+    # Build model
+    model = Model("observer_test")
+    model.add_block(u_src)
+    model.add_block(plant)
+    model.add_block(obs)
+
+    model.connect("u", "out", "plant", "u")
+    model.connect("u", "out", "observer", "u")
+    model.connect("plant", "y", "observer", "y")
+
+    dt = 0.1
+    T = 10.
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg)
+
+    logs = sim.run(logging=[
+            "plant.outputs.x",
+            "observer.outputs.x_hat",
+        ]
+    )
+
+    # Extract logs
+    t = sim.get_data("time")
+    x_true = sim.get_data("plant.outputs.x").squeeze()
+    x_hat = sim.get_data("observer.outputs.x_hat").squeeze()
+
+    # The observer should track the state with low error after a few steps
+    error = np.linalg.norm(x_true[-1] - x_hat[-1])
+    print(f"Final estimation error: {error}")
+
+
+    plt.figure()
+    plt.step(t, x_true, "--r", label="True State x", where="post")
+    plt.step(t, x_hat, '--b', label="Estimated State x_hat", where="post")
+    plt.xlabel("Time [s]")
+    plt.ylabel("State Value")
+    plt.title("Luenberger Observer State Estimation")
+    plt.legend()
+    plt.grid()
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

examples/basics/state_feedback/gui/parameters.py

@@ -0,0 +1,9 @@
+import numpy as np
+import control as ct
+
+A = np.array([[0.95, 0.1], [0, 0.98]])
+B = np.array([[1], [1]])
+C = np.array([[1., 0.]])
+
+K = ct.place(A, B, [0.9, 0.91])
+G = np.linalg.inv(C @ np.linalg.inv(np.eye(2) - A + B @ K) @ B)

examples/basics/state_feedback/gui/run.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from pySimBlocks.project import load_simulator_from_project
+from pySimBlocks.project.plot_from_config import plot_from_config
+
+try:
+    BASE_DIR = Path(__file__).parent.resolve()
+except Exception:
+    BASE_DIR = Path("")
+
+sim, plot_cfg = load_simulator_from_project(BASE_DIR / 'project.yaml')
+
+logs = sim.run()
+if True and plot_cfg is not None:
+    plot_from_config(logs, plot_cfg)

examples/basics/state_feedback/state_feedback.py

@@ -0,0 +1,102 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import control as ct
+
+from pySimBlocks import Model, Simulator, SimulationConfig
+from pySimBlocks.blocks.sources import  Step
+from pySimBlocks.blocks.controllers import  StateFeedback
+from pySimBlocks.blocks.systems import  LinearStateSpace
+
+
+def main():
+    # --- 1. Define system matrices (SISO example) ---
+    A = np.array([[0.95, 0.1], [0, 0.98]])
+    B = np.array([[1], [1]])
+    C = np.array([[1., 0.]])
+
+    K = ct.place(A, B, [0.9, 0.91])
+    G = np.linalg.inv(C @ np.linalg.inv(np.eye(2) - A + B @ K) @ B)
+
+    # --- 2. Create blocks ---
+    # Step : 0 -> 1 at start_time = 0.5 s
+    ref = Step(
+        name="ref",
+        value_before=np.array([[0.0]]),
+        value_after=np.array([[1.0]]),
+        start_time=0.5,
+    )
+
+    # State feedback controller
+    controller = StateFeedback(name="controller", K=K, G=G)
+
+    # Linear state-space system
+    plant = LinearStateSpace(
+        name="plant",
+        A=A, B=B, C=C,
+        x0=np.array([[0.], [0.]]),
+    )
+
+    # --- 3. Build the model ---
+    model = Model(name="state_feedback_control")
+    model.add_block(ref)
+    model.add_block(controller)
+    model.add_block(plant)
+
+    # Connect:
+    model.connect("ref", "out", "controller", "r")
+    model.connect("controller", "u", "plant", "u")
+    model.connect("plant", "x", "controller", "x")
+
+    # --- 4. Create the simulator ---
+    dt = 0.01  # 10 ms
+    T = 2.0  # 2 seconds
+    sim_cfg = SimulationConfig(dt, T)
+    sim = Simulator(model, sim_cfg)
+
+    # --- 5. Run simulation ---
+    logs = sim.run(logging=[
+            "ref.outputs.out",
+            "controller.outputs.u",
+            "plant.outputs.x",
+            "plant.outputs.y",
+        ],
+    )
+
+    # --- 6. Inspect / print some results ---
+    length = len(logs["plant.outputs.y"])
+
+    t = sim.get_data("time")
+    r = sim.get_data("ref.outputs.out").squeeze()
+    y = sim.get_data("plant.outputs.y").squeeze()
+    x = sim.get_data("plant.outputs.x").squeeze()
+    u = sim.get_data("controller.outputs.u").squeeze()
+
+    plt.figure()
+    plt.step(t, r, label="ref (step)", where="post")
+    plt.step(t, y, label="y (plant output)", where="post")
+    plt.legend()
+    plt.grid(True)
+    plt.xlabel("Time [s]")
+    plt.title("Reference tracking")
+
+
+    plt.figure()
+    plt.step(t, u, label="u = gain(ref)", where="post")
+    plt.legend()
+    plt.grid(True)
+    plt.xlabel("Time [s]")
+    plt.title("Control input")
+
+    plt.figure()
+    plt.step(t, x[:, 0], label="x1 (state 1)", where="post")
+    plt.step(t, x[:, 1], label="x2 (state 2)", where="post")
+    plt.legend()
+    plt.grid(True)
+    plt.xlabel("Time [s]")
+    plt.title("States evolution")
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()