{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "*This notebook contains course material from [CBE30338](https://jckantor.github.io/CBE30338)\n", "by Jeffrey Kantor (jeff at nd.edu); the content is available [on Github](https://github.com/jckantor/CBE30338.git).\n", "The text is released under the [CC-BY-NC-ND-4.0 license](https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode),\n", "and code is released under the [MIT license](https://opensource.org/licenses/MIT).*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "< [PID Control](http://nbviewer.jupyter.org/github/jckantor/CBE30338/blob/master/notebooks/04.00-PID_Control.ipynb) | [Contents](toc.ipynb) | [PID Control with Setpoint Weighting](http://nbviewer.jupyter.org/github/jckantor/CBE30338/blob/master/notebooks/04.02-PID_Control_with_Setpoint_Weighting.ipynb) >
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Implementing PID Controllers with Python Yield Statement\n",
"\n",
"Up to this point we have been implementing simple control strategies where the manipulated variable depends only on current values of the process variable and setpoint. Relay control, for example, can be expressed mathematically as\n",
"\n",
"$$MV = Kp (SP - PV)$$\n",
"\n",
"and implemented in Python as\n",
"\n",
" def proportional(PV, SP):\n",
" MV = Kp * (SP - PV)\n",
" return MV\n",
"\n",
"Python functions carry no persistent memory from one use to the next, which is fine if the control algorithm requires no knowledge of the past.\n",
"\n",
"The problem, however, is that PID control requires use of past measurements. Proportional-integral control, for example, tracks the cumulative sum of the differences between setpoint and the process variable. Because a Python function disappears completely after the return statement, the value of the cumulative sum must be stored somewhere else in code. The coding problem is to figure out how and where to store that information between calls to the algorithm. We seek coding methods that encapsulate the state of control algorithms.\n",
"\n",
"There are several ways persistence can be provided in Python (roughly in order of increasing capability and complexity):\n",
"\n",
"* Generators written using the Python `yield` statement\n",
"* Classes\n",
"* Asynchronous programming with co-routines\n",
"* Threads\n",
"\n",
"Classes, in particular, are a tool for encapsulating data and functionality within a single software entity. Classes are widely used in Python programming, and should eventually become part of every Python programmer's toolkit.\n",
"\n",
"As we demonstrate below, however, the Python `yield` statement is often sufficient to write self-contained implementations of control algorithm. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Python Yield Statement\n",
"\n",
"The cells below provide a very brief introduction to Python `yield` statement. More information can be found [here](https://jeffknupp.com/blog/2013/04/07/improve-your-python-yield-and-generators-explained/)\n",
"\n",
"A function incorporating a `yield` statement creates a persistent object called a generator. Like the `return` statement, `yield` says to return a value and control to the calling routine. Unlike the `return` statement, however, the generator goes into a suspended state following the `yield`. On the next use it will pick up execution right where execution left off.\n",
"\n",
"Here's an example produces a generator for four numbers."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"def numbers_gen():\n",
" yield 0\n",
" yield 1\n",
" yield 2.7182818\n",
" yield 3.1415926"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To use this, first create the actual generator object that will do the work. "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"numbers = numbers_gen()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are several ways to get values from a generator. One way is using the `next()` function which executes generator until the next `yield` statement is encountered, then return the value."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2.7182818\n",
"3.1415926\n"
]
}
],
"source": [
"print(next(numbers))\n",
"print(next(numbers))\n",
"print(next(numbers))\n",
"print(next(numbers))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The generator object `numbers` has a `send` method for sending information to the generator and causing it to execute until the next `yield`. For this case all we need to send is `None`."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2.7182818\n",
"3.1415926\n"
]
}
],
"source": [
"numbers = numbers_gen()\n",
"print(numbers.send(None))\n",
"print(numbers.send(None))\n",
"print(numbers.send(None))\n",
"print(numbers.send(None))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `send` method provides two-way communication with a generator. Here's an example of how that works."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"def texter_gen():\n",
" a = yield \"Started\"\n",
" b = yield a\n",
" yield b"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Started\n",
"Hello, World\n",
"Go Irish\n"
]
}
],
"source": [
"texter = texter_gen()\n",
"print(texter.send(None))\n",
"print(texter.send(\"Hello, World\"))\n",
"print(texter.send(\"Go Irish\"))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There's a subtle detail here that easy to miss. The first `send` starts the generator which then executes up to the first yield statement. At that point execution halts and the message \"Started\" is sent to the calling routine. The second `send` causes execution to pick up again and puts the message \"Hello, World\" into variable `a`. \n",
"\n",
"An important point is that the first `send` to a generator must always be `None`.\n",
"\n",
"In the next example `yield` is placed inside an infinite loop. This function creates generators that return the square of the number sent."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"# A function that will create generators\n",
"def our_numbers():\n",
" n = 0\n",
" while True:\n",
" n = yield n*n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"16\n",
"144\n",
"1764\n"
]
}
],
"source": [
"# create a generator\n",
"numbers = our_numbers()\n",
"\n",
"# start the generator\n",
"numbers.send(None) \n",
"\n",
"# send values to the generator and print the results\n",
"print(numbers.send(4))\n",
"print(numbers.send(12))\n",
"print(numbers.send(42))\n",
"\n",
"# how to remove a generator when finished using it.\n",
"numbers.close()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's now consider how generators may be used for process control applications. The next cell defines a function that will create generators that perform as proportional controllers with specified gain $K_p$ and setpoint $SP$. When sent a current value of the process variable `PV`, the controllers will return a value for the manipulated variable `MV`."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"def proportional(Kp, SP):\n",
" \"\"\"Creates proportional controllers with specified gain and setpoint.\"\"\"\n",
" MV = 0\n",
" while True:\n",
" PV = yield MV\n",
" MV = Kp * (SP - PV)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's create and initialize two controllers with the same setpoint but different gains."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"controller1 = proportional(10, 40)\n",
"controller1.send(None)\n",
"\n",
"controller2 = proportional(1, 40)\n",
"controller2.send(None)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's see how these controllers would respond to a PV value of 35."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Controller 1: MV = 50\n",
"Controller 2: MV = 5\n"
]
}
],
"source": [
"PV = 35\n",
"\n",
"print(\"Controller 1: MV = \", controller1.send(PV))\n",
"print(\"Controller 2: MV = \", controller2.send(PV))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is a important feature from a coding and maintenance perspective. We need to create and maintain only one copy of the control algorithm."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## PID Control Implementation\n",
"\n",
"A simple form of Proportional-Integral control is an example of a controller with internal state. In velocity form,\n",
"\n",
"\\begin{align}\n",
"MV_k & = \\overline{MV} + K_P e_k + K_I \\sum_{k'=0}^k e_{k'}(t_k - t_{k-1}) + K_D \\frac{e_k - e_{k-1}}{t_k - t_{k-1}}\n",
"\\end{align}\n",
"\n",
"where $e_k$ is the difference between setpoint and measured process variable\n",
"\n",
"\\begin{align}\n",
"e_k = SP_k - PV_k\n",
"\\end{align}\n",
"\n",
"$K_P$, $K_I$, and $K_D$ are control constants, and $t_k$ is the sampling time. \n",
"\n",
"The following cell provides a direct implementation of this algorithm as a Python generator."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"def PID(Kp, Ki, Kd, MV_bar=0):\n",
" # initialize stored data\n",
" e_prev = 0\n",
" t_prev = -100\n",
" I = 0\n",
" \n",
" # initial control\n",
" MV = MV_bar\n",
" \n",
" while True:\n",
" # yield MV, wait for new t, PV, SP\n",
" t, PV, SP = yield MV\n",
" \n",
" # PID calculations\n",
" e = SP - PV\n",
" \n",
" P = Kp*e\n",
" I = I + Ki*e*(t - t_prev)\n",
" D = Kd*(e - e_prev)/(t - t_prev)\n",
" \n",
" MV = MV_bar + P + I + D\n",
" \n",
" # update stored data for next iteration\n",
" e_prev = e\n",
" t_prev = t"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Simulation\n",
"\n",
"Let's see how well this PID implementation works. We'll perform the simulation with a setpoint that starts at room temperature, then rises to 50°C at $t = 50$ seconds. The data historian will record values of the setpoint, process variable, computed manipulated variable, and the actual value of the manipulated variable."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
" "
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.6.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}