From d851b9ba4f1e88fc3e3193c9aeaaf954132d9747 Mon Sep 17 00:00:00 2001 From: RamCharanThota Date: Wed, 1 Nov 2023 12:21:32 +1100 Subject: [PATCH] implemented and tested simple pydrake example --- .gitignore | 1 + .../pydrake_simple_example-checkpoint.ipynb | 419 ++++++++++++++++++ .../pydrake_simple_example.ipynb | 419 ++++++++++++++++++ 3 files changed, 839 insertions(+) create mode 100644 .gitignore create mode 100644 programming_examples/.ipynb_checkpoints/pydrake_simple_example-checkpoint.ipynb create mode 100644 programming_examples/pydrake_simple_example.ipynb diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6f1555e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*pydrakeenv diff --git a/programming_examples/.ipynb_checkpoints/pydrake_simple_example-checkpoint.ipynb b/programming_examples/.ipynb_checkpoints/pydrake_simple_example-checkpoint.ipynb new file mode 100644 index 0000000..3653c01 --- /dev/null +++ b/programming_examples/.ipynb_checkpoints/pydrake_simple_example-checkpoint.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "07a9a65f", + "metadata": {}, + "outputs": [], + "source": [ + "from pydrake.symbolic import Variable\n", + "from pydrake.systems.primitives import SymbolicVectorSystem\n", + "\n", + "# Define a new symbolic Variable\n", + "x = Variable(\"x\")\n", + "\n", + "# Define the System. \n", + "continuous_vector_system = SymbolicVectorSystem(state=[x], dynamics=[-x + x**3], output=[x])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2ef38f2e", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the System. Note the additional argument specifying the time period.\n", + "discrete_vector_system = SymbolicVectorSystem(state=[x], dynamics=[x**3], output=[x], time_period=1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1ac0569e-12f7-4017-8c0b-613a7b7cc574", + "metadata": {}, + "outputs": [], + "source": [ + "from pydrake.systems.framework import LeafSystem\n", + "\n", + "# Define the system.\n", + "class SimpleContinuousTimeSystem(LeafSystem):\n", + " def __init__(self):\n", + " LeafSystem.__init__(self)\n", + "\n", + " state_index = self.DeclareContinuousState(1) # One state variable.\n", + " self.DeclareStateOutputPort(\"y\", state_index) # One output: y=x.\n", + "\n", + " # xdot(t) = -x(t) + x^3(t)\n", + " def DoCalcTimeDerivatives(self, context, derivatives):\n", + " x = context.get_continuous_state_vector().GetAtIndex(0)\n", + " xdot = -x + x**3\n", + " derivatives.get_mutable_vector().SetAtIndex(0, xdot)\n", + "\n", + "# Instantiate the System\n", + "continuous_system = SimpleContinuousTimeSystem()\n", + "\n", + "\n", + "# Define the system.\n", + "class SimpleDiscreteTimeSystem(LeafSystem):\n", + " def __init__(self):\n", + " LeafSystem.__init__(self)\n", + "\n", + " state_index = self.DeclareDiscreteState(1) # One state variable.\n", + " self.DeclareStateOutputPort(\"y\", state_index) # One output: y=x.\n", + " self.DeclarePeriodicDiscreteUpdateEvent(\n", + " period_sec=1.0, # One second time step.\n", + " offset_sec=0.0, # The first event is at time zero.\n", + " update=self.Update) # Call the Update method defined below.\n", + "\n", + " # x[n+1] = x^3[n]\n", + " def Update(self, context, discrete_state):\n", + " x = context.get_discrete_state_vector().GetAtIndex(0)\n", + " x_next = x**3\n", + " discrete_state.get_mutable_vector().SetAtIndex(0, x_next)\n", + "\n", + "# Instantiate the System\n", + "discrete_system = SimpleDiscreteTimeSystem()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b44d0caf-ff74-4a7a-ad1d-64ba8f871a01", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pydrake.systems.analysis import Simulator\n", + "from pydrake.systems.framework import DiagramBuilder\n", + "from pydrake.systems.primitives import LogVectorOutput\n", + "\n", + "# Create a simple block diagram containing our system.\n", + "builder = DiagramBuilder()\n", + "system = builder.AddSystem(SimpleContinuousTimeSystem())\n", + "logger = LogVectorOutput(system.get_output_port(0), builder)\n", + "diagram = builder.Build()\n", + "\n", + "# Set the initial conditions, x(0).\n", + "context = diagram.CreateDefaultContext()\n", + "context.SetContinuousState([0.9])\n", + "\n", + "# Create the simulator, and simulate for 10 seconds.\n", + "simulator = Simulator(diagram, context)\n", + "simulator.AdvanceTo(10)\n", + "\n", + "# Plot the results.\n", + "log = logger.FindLog(context)\n", + "plt.figure()\n", + "plt.plot(log.sample_times(), log.data().transpose())\n", + "plt.xlabel('t')\n", + "plt.ylabel('y(t)');" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "024cd21a-1f7b-483a-88c0-e6a222a140d4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a simple block diagram containing our system.\n", + "builder = DiagramBuilder()\n", + "system = builder.AddSystem(SimpleDiscreteTimeSystem())\n", + "logger = LogVectorOutput(system.get_output_port(0), builder)\n", + "diagram = builder.Build()\n", + "\n", + "# Create the simulator.\n", + "simulator = Simulator(diagram)\n", + "\n", + "# Set the initial conditions, x(0).\n", + "state = simulator.get_mutable_context().get_mutable_discrete_state_vector()\n", + "state.SetFromVector([0.9])\n", + "\n", + "# Simulate for 10 seconds.\n", + "simulator.AdvanceTo(10)\n", + "\n", + "# Plot the results.\n", + "log = logger.FindLog(simulator.get_context())\n", + "plt.figure()\n", + "plt.stem(log.sample_times(), log.data().transpose())\n", + "plt.xlabel('n')\n", + "plt.ylabel('y[n]');" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f93e7834-a5a5-46e5-9124-ceb23105f544", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "_18\n", + "\n", + "\n", + "cluster18diagram\n", + "\n", + "Diagram\n", + "name=diagram\n", + "\n", + "\n", + "clusters18in\n", + "\n", + "input ports\n", + "\n", + "\n", + "clusters18out\n", + "\n", + "output ports\n", + "\n", + "\n", + "cluster18subsystems\n", + "\n", + "\n", + "\n", + "\n", + "s18in\n", + "\n", + "controller_desired_state\n", + "\n", + "\n", + "\n", + "s15\n", + "\n", + "PidController\n", + "name=controller\n", + "\n", + "estimated_state\n", + "\n", + "control\n", + "\n", + "desired_state\n", + "\n", + "\n", + "\n", + "s18in:e->s15:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s18out\n", + "\n", + "pendulum_state\n", + "\n", + "\n", + "\n", + "s14\n", + "\n", + "PendulumPlant\n", + "name=pendulum\n", + "\n", + "tau\n", + "\n", + "state\n", + "\n", + "\n", + "\n", + "s14:e->s18out:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s14:e->s15:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s16\n", + "\n", + "VectorLogSink\n", + "name=logger\n", + "\n", + "data\n", + "\n", + "\n", + "\n", + "\n", + "s14:e->s16:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s15:e->s14:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\\n\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pydot\n", + "from IPython.display import SVG, display\n", + "from pydrake.examples import PendulumPlant\n", + "from pydrake.systems.analysis import Simulator\n", + "from pydrake.systems.controllers import PidController\n", + "from pydrake.systems.framework import DiagramBuilder\n", + "from pydrake.systems.primitives import LogVectorOutput\n", + "\n", + "builder = DiagramBuilder()\n", + "\n", + "# First add the pendulum.\n", + "pendulum = builder.AddNamedSystem(\"pendulum\", PendulumPlant())\n", + "\n", + "# Add a PID controller.\n", + "controller = builder.AddNamedSystem(\"controller\",\n", + " PidController(kp=[10.], ki=[1.], kd=[1.]))\n", + "\n", + "# Now \"wire up\" the controller to the plant.\n", + "builder.Connect(pendulum.get_state_output_port(),\n", + " controller.get_input_port_estimated_state())\n", + "builder.Connect(controller.get_output_port_control(), pendulum.get_input_port())\n", + "\n", + "# Make the desired_state input of the controller an input to the diagram.\n", + "builder.ExportInput(controller.get_input_port_desired_state())\n", + "# Make the pendulum state an output from the diagram.\n", + "builder.ExportOutput(pendulum.get_state_output_port())\n", + "\n", + "# Log the state of the pendulum.\n", + "logger = LogVectorOutput(pendulum.get_state_output_port(), builder)\n", + "logger.set_name(\"logger\")\n", + "\n", + "diagram = builder.Build()\n", + "diagram.set_name(\"diagram\")\n", + "\n", + "# Visualize the diagram.\n", + "display(SVG(pydot.graph_from_dot_data(\n", + " diagram.GetGraphvizString(max_depth=2))[0].create_svg()))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4c767a62-1682-456a-985d-6e31516b9361", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a simulator to run this diagram.\n", + "simulator = Simulator(diagram)\n", + "context = simulator.get_mutable_context()\n", + "\n", + "# We'll try to regulate the pendulum to a particular angle.\n", + "desired_angle = np.pi/2.\n", + "\n", + "# First we extract the subsystem context for the pendulum.\n", + "pendulum_context = diagram.GetMutableSubsystemContext(pendulum, context)\n", + "# Then we can set the pendulum state, which is (theta, thetadot).\n", + "pendulum_context.get_mutable_continuous_state_vector().SetFromVector(\n", + " [desired_angle + 0.1, 0.2])\n", + "\n", + "# The diagram has a single input port (port index 0), which is the desired_state.\n", + "diagram.get_input_port(0).FixValue(context, [desired_angle, 0.])\n", + "\n", + "# Clear the logger only because we've written this notebook with the opportunity to\n", + "# simulate multiple times (in this cell) using the same logger object. This is\n", + "# often not needed.\n", + "logger.FindMutableLog(context).Clear()\n", + "\n", + "# Simulate for 10 seconds.\n", + "simulator.AdvanceTo(20);\n", + "\n", + "# Plot the results.\n", + "log = logger.FindLog(simulator.get_context())\n", + "t = log.sample_times()\n", + "plt.figure()\n", + "# Plot theta.\n", + "plt.plot(t, log.data()[0,:],'.-')\n", + "# Draw a line for the desired angle.\n", + "plt.plot([t[0], t[-1]], [desired_angle, desired_angle], 'g' )\n", + "plt.xlabel('time (seconds)')\n", + "plt.ylabel('theta (rad)')\n", + "plt.title('PID Control of the Pendulum');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50040312-f9bb-49cb-a411-384b4dc189d2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/programming_examples/pydrake_simple_example.ipynb b/programming_examples/pydrake_simple_example.ipynb new file mode 100644 index 0000000..3653c01 --- /dev/null +++ b/programming_examples/pydrake_simple_example.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "07a9a65f", + "metadata": {}, + "outputs": [], + "source": [ + "from pydrake.symbolic import Variable\n", + "from pydrake.systems.primitives import SymbolicVectorSystem\n", + "\n", + "# Define a new symbolic Variable\n", + "x = Variable(\"x\")\n", + "\n", + "# Define the System. \n", + "continuous_vector_system = SymbolicVectorSystem(state=[x], dynamics=[-x + x**3], output=[x])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2ef38f2e", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the System. Note the additional argument specifying the time period.\n", + "discrete_vector_system = SymbolicVectorSystem(state=[x], dynamics=[x**3], output=[x], time_period=1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1ac0569e-12f7-4017-8c0b-613a7b7cc574", + "metadata": {}, + "outputs": [], + "source": [ + "from pydrake.systems.framework import LeafSystem\n", + "\n", + "# Define the system.\n", + "class SimpleContinuousTimeSystem(LeafSystem):\n", + " def __init__(self):\n", + " LeafSystem.__init__(self)\n", + "\n", + " state_index = self.DeclareContinuousState(1) # One state variable.\n", + " self.DeclareStateOutputPort(\"y\", state_index) # One output: y=x.\n", + "\n", + " # xdot(t) = -x(t) + x^3(t)\n", + " def DoCalcTimeDerivatives(self, context, derivatives):\n", + " x = context.get_continuous_state_vector().GetAtIndex(0)\n", + " xdot = -x + x**3\n", + " derivatives.get_mutable_vector().SetAtIndex(0, xdot)\n", + "\n", + "# Instantiate the System\n", + "continuous_system = SimpleContinuousTimeSystem()\n", + "\n", + "\n", + "# Define the system.\n", + "class SimpleDiscreteTimeSystem(LeafSystem):\n", + " def __init__(self):\n", + " LeafSystem.__init__(self)\n", + "\n", + " state_index = self.DeclareDiscreteState(1) # One state variable.\n", + " self.DeclareStateOutputPort(\"y\", state_index) # One output: y=x.\n", + " self.DeclarePeriodicDiscreteUpdateEvent(\n", + " period_sec=1.0, # One second time step.\n", + " offset_sec=0.0, # The first event is at time zero.\n", + " update=self.Update) # Call the Update method defined below.\n", + "\n", + " # x[n+1] = x^3[n]\n", + " def Update(self, context, discrete_state):\n", + " x = context.get_discrete_state_vector().GetAtIndex(0)\n", + " x_next = x**3\n", + " discrete_state.get_mutable_vector().SetAtIndex(0, x_next)\n", + "\n", + "# Instantiate the System\n", + "discrete_system = SimpleDiscreteTimeSystem()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b44d0caf-ff74-4a7a-ad1d-64ba8f871a01", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pydrake.systems.analysis import Simulator\n", + "from pydrake.systems.framework import DiagramBuilder\n", + "from pydrake.systems.primitives import LogVectorOutput\n", + "\n", + "# Create a simple block diagram containing our system.\n", + "builder = DiagramBuilder()\n", + "system = builder.AddSystem(SimpleContinuousTimeSystem())\n", + "logger = LogVectorOutput(system.get_output_port(0), builder)\n", + "diagram = builder.Build()\n", + "\n", + "# Set the initial conditions, x(0).\n", + "context = diagram.CreateDefaultContext()\n", + "context.SetContinuousState([0.9])\n", + "\n", + "# Create the simulator, and simulate for 10 seconds.\n", + "simulator = Simulator(diagram, context)\n", + "simulator.AdvanceTo(10)\n", + "\n", + "# Plot the results.\n", + "log = logger.FindLog(context)\n", + "plt.figure()\n", + "plt.plot(log.sample_times(), log.data().transpose())\n", + "plt.xlabel('t')\n", + "plt.ylabel('y(t)');" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "024cd21a-1f7b-483a-88c0-e6a222a140d4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a simple block diagram containing our system.\n", + "builder = DiagramBuilder()\n", + "system = builder.AddSystem(SimpleDiscreteTimeSystem())\n", + "logger = LogVectorOutput(system.get_output_port(0), builder)\n", + "diagram = builder.Build()\n", + "\n", + "# Create the simulator.\n", + "simulator = Simulator(diagram)\n", + "\n", + "# Set the initial conditions, x(0).\n", + "state = simulator.get_mutable_context().get_mutable_discrete_state_vector()\n", + "state.SetFromVector([0.9])\n", + "\n", + "# Simulate for 10 seconds.\n", + "simulator.AdvanceTo(10)\n", + "\n", + "# Plot the results.\n", + "log = logger.FindLog(simulator.get_context())\n", + "plt.figure()\n", + "plt.stem(log.sample_times(), log.data().transpose())\n", + "plt.xlabel('n')\n", + "plt.ylabel('y[n]');" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f93e7834-a5a5-46e5-9124-ceb23105f544", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "_18\n", + "\n", + "\n", + "cluster18diagram\n", + "\n", + "Diagram\n", + "name=diagram\n", + "\n", + "\n", + "clusters18in\n", + "\n", + "input ports\n", + "\n", + "\n", + "clusters18out\n", + "\n", + "output ports\n", + "\n", + "\n", + "cluster18subsystems\n", + "\n", + "\n", + "\n", + "\n", + "s18in\n", + "\n", + "controller_desired_state\n", + "\n", + "\n", + "\n", + "s15\n", + "\n", + "PidController\n", + "name=controller\n", + "\n", + "estimated_state\n", + "\n", + "control\n", + "\n", + "desired_state\n", + "\n", + "\n", + "\n", + "s18in:e->s15:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s18out\n", + "\n", + "pendulum_state\n", + "\n", + "\n", + "\n", + "s14\n", + "\n", + "PendulumPlant\n", + "name=pendulum\n", + "\n", + "tau\n", + "\n", + "state\n", + "\n", + "\n", + "\n", + "s14:e->s18out:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s14:e->s15:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s16\n", + "\n", + "VectorLogSink\n", + "name=logger\n", + "\n", + "data\n", + "\n", + "\n", + "\n", + "\n", + "s14:e->s16:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s15:e->s14:w\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\\n\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pydot\n", + "from IPython.display import SVG, display\n", + "from pydrake.examples import PendulumPlant\n", + "from pydrake.systems.analysis import Simulator\n", + "from pydrake.systems.controllers import PidController\n", + "from pydrake.systems.framework import DiagramBuilder\n", + "from pydrake.systems.primitives import LogVectorOutput\n", + "\n", + "builder = DiagramBuilder()\n", + "\n", + "# First add the pendulum.\n", + "pendulum = builder.AddNamedSystem(\"pendulum\", PendulumPlant())\n", + "\n", + "# Add a PID controller.\n", + "controller = builder.AddNamedSystem(\"controller\",\n", + " PidController(kp=[10.], ki=[1.], kd=[1.]))\n", + "\n", + "# Now \"wire up\" the controller to the plant.\n", + "builder.Connect(pendulum.get_state_output_port(),\n", + " controller.get_input_port_estimated_state())\n", + "builder.Connect(controller.get_output_port_control(), pendulum.get_input_port())\n", + "\n", + "# Make the desired_state input of the controller an input to the diagram.\n", + "builder.ExportInput(controller.get_input_port_desired_state())\n", + "# Make the pendulum state an output from the diagram.\n", + "builder.ExportOutput(pendulum.get_state_output_port())\n", + "\n", + "# Log the state of the pendulum.\n", + "logger = LogVectorOutput(pendulum.get_state_output_port(), builder)\n", + "logger.set_name(\"logger\")\n", + "\n", + "diagram = builder.Build()\n", + "diagram.set_name(\"diagram\")\n", + "\n", + "# Visualize the diagram.\n", + "display(SVG(pydot.graph_from_dot_data(\n", + " diagram.GetGraphvizString(max_depth=2))[0].create_svg()))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4c767a62-1682-456a-985d-6e31516b9361", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a simulator to run this diagram.\n", + "simulator = Simulator(diagram)\n", + "context = simulator.get_mutable_context()\n", + "\n", + "# We'll try to regulate the pendulum to a particular angle.\n", + "desired_angle = np.pi/2.\n", + "\n", + "# First we extract the subsystem context for the pendulum.\n", + "pendulum_context = diagram.GetMutableSubsystemContext(pendulum, context)\n", + "# Then we can set the pendulum state, which is (theta, thetadot).\n", + "pendulum_context.get_mutable_continuous_state_vector().SetFromVector(\n", + " [desired_angle + 0.1, 0.2])\n", + "\n", + "# The diagram has a single input port (port index 0), which is the desired_state.\n", + "diagram.get_input_port(0).FixValue(context, [desired_angle, 0.])\n", + "\n", + "# Clear the logger only because we've written this notebook with the opportunity to\n", + "# simulate multiple times (in this cell) using the same logger object. This is\n", + "# often not needed.\n", + "logger.FindMutableLog(context).Clear()\n", + "\n", + "# Simulate for 10 seconds.\n", + "simulator.AdvanceTo(20);\n", + "\n", + "# Plot the results.\n", + "log = logger.FindLog(simulator.get_context())\n", + "t = log.sample_times()\n", + "plt.figure()\n", + "# Plot theta.\n", + "plt.plot(t, log.data()[0,:],'.-')\n", + "# Draw a line for the desired angle.\n", + "plt.plot([t[0], t[-1]], [desired_angle, desired_angle], 'g' )\n", + "plt.xlabel('time (seconds)')\n", + "plt.ylabel('theta (rad)')\n", + "plt.title('PID Control of the Pendulum');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50040312-f9bb-49cb-a411-384b4dc189d2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}