automatic import of python-simple-pid

3 files changed, 460 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..8588f2e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/simple-pid-1.0.1.tar.gz
diff --git a/python-simple-pid.spec b/python-simple-pid.spec
new file mode 100644
index 0000000..4a930af
--- /dev/null
+++ b/python-simple-pid.spec
@@ -0,0 +1,458 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-simple-pid
+Version:	1.0.1
+Release:	1
+Summary:	A simple, easy to use PID controller
+License:	MIT
+URL:		https://github.com/m-lundberg/simple-pid
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/00/27/73b35b5e57c0dec32cf180724d6c7ac2075b655f96c79217632f9ba9c7e1/simple-pid-1.0.1.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-m2r
+Requires:	python3-sphinx-rtd-theme
+
+%description
+# simple-pid
+
+[![Travis](https://travis-ci.com/m-lundberg/simple-pid.svg?branch=master)](https://travis-ci.com/m-lundberg/simple-pid)
+[![PyPI](https://img.shields.io/pypi/v/simple-pid.svg)](https://pypi.org/project/simple-pid/)
+[![Read the Docs](https://img.shields.io/readthedocs/simple-pid.svg)](https://simple-pid.readthedocs.io/)
+[![License](https://img.shields.io/github/license/m-lundberg/simple-pid.svg)](https://github.com/m-lundberg/simple-pid/blob/master/LICENSE.md)
+[![Downloads](https://pepy.tech/badge/simple-pid)](https://pepy.tech/project/simple-pid)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+A simple and easy to use PID controller in Python. If you want a PID controller without external dependencies that just works, this is for you! The PID was designed to be robust with help from [Brett Beauregards guide](http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/).
+
+Usage is very simple:
+
+```python
+from simple_pid import PID
+pid = PID(1, 0.1, 0.05, setpoint=1)
+
+# Assume we have a system we want to control in controlled_system
+v = controlled_system.update(0)
+
+while True:
+    # Compute new output from the PID according to the systems current value
+    control = pid(v)
+
+    # Feed the PID output to the system and get its current value
+    v = controlled_system.update(control)
+```
+
+Complete API documentation can be found [here](https://simple-pid.readthedocs.io/en/latest/simple_pid.html#module-simple_pid.PID).
+
+## Installation
+To install, run:
+```
+pip install simple-pid
+```
+
+## Usage
+The `PID` class implements `__call__()`, which means that to compute a new output value, you simply call the object like this:
+```python
+output = pid(current_value)
+```
+
+### The basics
+The PID works best when it is updated at regular intervals. To achieve this, set `sample_time` to the amount of time there should be between each update and then call the PID every time in the program loop. A new output will only be calculated when `sample_time` seconds has passed:
+```python
+pid.sample_time = 0.01  # Update every 0.01 seconds
+
+while True:
+    output = pid(current_value)
+```
+
+To set the setpoint, ie. the value that the PID is trying to achieve, simply set it like this:
+```python
+pid.setpoint = 10
+```
+
+The tunings can be changed any time when the PID is running. They can either be set individually or all at once:
+```python
+pid.Ki = 1.0
+pid.tunings = (1.0, 0.2, 0.4)
+```
+
+To use the PID in [reverse mode](http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-direction/), meaning that an increase in the input leads to a decrease in the output (like when cooling for example), you can set the tunings to negative values:
+
+```python
+pid.tunings = (-1.0, -0.1, 0)
+```
+
+Note that all the tunings should have the same sign.
+
+In order to get output values in a certain range, and also to avoid [integral windup](https://en.wikipedia.org/wiki/Integral_windup) (since the integral term will never be allowed to grow outside of these limits), the output can be limited to a range:
+```python
+pid.output_limits = (0, 10)    # Output value will be between 0 and 10
+pid.output_limits = (0, None)  # Output will always be above 0, but with no upper bound
+```
+
+### Other features
+#### Auto mode
+To disable the PID so that no new values are computed, set auto mode to False:
+```python
+pid.auto_mode = False  # No new values will be computed when pid is called
+pid.auto_mode = True   # pid is enabled again
+```
+When disabling the PID and controlling a system manually, it might be useful to tell the PID controller where to start from when giving back control to it. This can be done by enabling auto mode like this:
+```python
+pid.set_auto_mode(True, last_output=8.0)
+```
+This will set the I-term to the value given to `last_output`, meaning that if the system that is being controlled was stable at that output value the PID will keep the system stable if started from that point, without any big bumps in the output when turning the PID back on.
+
+#### Observing separate components
+When tuning the PID, it can be useful to see how each of the components contribute to the output. They can be seen like this:
+```python
+p, i, d = pid.components  # The separate terms are now in p, i, d
+```
+
+#### Proportional on measurement
+To eliminate overshoot in certain types of systems, you can calculate the [proportional term directly on the measurement](http://brettbeauregard.com/blog/2017/06/introducing-proportional-on-measurement/) instead of the error. This can be enabled like this:
+```python
+pid.proportional_on_measurement = True
+```
+
+#### Error mapping
+To transform the error value to another domain before doing any computations on it, you can supply an `error_map` callback function to the PID. The callback function should take one argument which is the error from the setpoint. This can be used e.g. to get a degree value error in a yaw angle control with values between [-pi, pi):
+```python
+import math
+
+def pi_clip(angle):
+    if angle > 0:
+        if angle > math.pi:
+            return angle - 2*math.pi
+    else:
+        if angle < -math.pi:
+            return angle + 2*math.pi
+    return angle
+
+pid.error_map = pi_clip
+```
+
+## Tests
+Use the following to run tests:
+```
+tox
+```
+
+## License
+Licensed under the [MIT License](https://github.com/m-lundberg/simple-pid/blob/master/LICENSE.md).
+
+
+
+
+%package -n python3-simple-pid
+Summary:	A simple, easy to use PID controller
+Provides:	python-simple-pid
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-simple-pid
+# simple-pid
+
+[![Travis](https://travis-ci.com/m-lundberg/simple-pid.svg?branch=master)](https://travis-ci.com/m-lundberg/simple-pid)
+[![PyPI](https://img.shields.io/pypi/v/simple-pid.svg)](https://pypi.org/project/simple-pid/)
+[![Read the Docs](https://img.shields.io/readthedocs/simple-pid.svg)](https://simple-pid.readthedocs.io/)
+[![License](https://img.shields.io/github/license/m-lundberg/simple-pid.svg)](https://github.com/m-lundberg/simple-pid/blob/master/LICENSE.md)
+[![Downloads](https://pepy.tech/badge/simple-pid)](https://pepy.tech/project/simple-pid)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+A simple and easy to use PID controller in Python. If you want a PID controller without external dependencies that just works, this is for you! The PID was designed to be robust with help from [Brett Beauregards guide](http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/).
+
+Usage is very simple:
+
+```python
+from simple_pid import PID
+pid = PID(1, 0.1, 0.05, setpoint=1)
+
+# Assume we have a system we want to control in controlled_system
+v = controlled_system.update(0)
+
+while True:
+    # Compute new output from the PID according to the systems current value
+    control = pid(v)
+
+    # Feed the PID output to the system and get its current value
+    v = controlled_system.update(control)
+```
+
+Complete API documentation can be found [here](https://simple-pid.readthedocs.io/en/latest/simple_pid.html#module-simple_pid.PID).
+
+## Installation
+To install, run:
+```
+pip install simple-pid
+```
+
+## Usage
+The `PID` class implements `__call__()`, which means that to compute a new output value, you simply call the object like this:
+```python
+output = pid(current_value)
+```
+
+### The basics
+The PID works best when it is updated at regular intervals. To achieve this, set `sample_time` to the amount of time there should be between each update and then call the PID every time in the program loop. A new output will only be calculated when `sample_time` seconds has passed:
+```python
+pid.sample_time = 0.01  # Update every 0.01 seconds
+
+while True:
+    output = pid(current_value)
+```
+
+To set the setpoint, ie. the value that the PID is trying to achieve, simply set it like this:
+```python
+pid.setpoint = 10
+```
+
+The tunings can be changed any time when the PID is running. They can either be set individually or all at once:
+```python
+pid.Ki = 1.0
+pid.tunings = (1.0, 0.2, 0.4)
+```
+
+To use the PID in [reverse mode](http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-direction/), meaning that an increase in the input leads to a decrease in the output (like when cooling for example), you can set the tunings to negative values:
+
+```python
+pid.tunings = (-1.0, -0.1, 0)
+```
+
+Note that all the tunings should have the same sign.
+
+In order to get output values in a certain range, and also to avoid [integral windup](https://en.wikipedia.org/wiki/Integral_windup) (since the integral term will never be allowed to grow outside of these limits), the output can be limited to a range:
+```python
+pid.output_limits = (0, 10)    # Output value will be between 0 and 10
+pid.output_limits = (0, None)  # Output will always be above 0, but with no upper bound
+```
+
+### Other features
+#### Auto mode
+To disable the PID so that no new values are computed, set auto mode to False:
+```python
+pid.auto_mode = False  # No new values will be computed when pid is called
+pid.auto_mode = True   # pid is enabled again
+```
+When disabling the PID and controlling a system manually, it might be useful to tell the PID controller where to start from when giving back control to it. This can be done by enabling auto mode like this:
+```python
+pid.set_auto_mode(True, last_output=8.0)
+```
+This will set the I-term to the value given to `last_output`, meaning that if the system that is being controlled was stable at that output value the PID will keep the system stable if started from that point, without any big bumps in the output when turning the PID back on.
+
+#### Observing separate components
+When tuning the PID, it can be useful to see how each of the components contribute to the output. They can be seen like this:
+```python
+p, i, d = pid.components  # The separate terms are now in p, i, d
+```
+
+#### Proportional on measurement
+To eliminate overshoot in certain types of systems, you can calculate the [proportional term directly on the measurement](http://brettbeauregard.com/blog/2017/06/introducing-proportional-on-measurement/) instead of the error. This can be enabled like this:
+```python
+pid.proportional_on_measurement = True
+```
+
+#### Error mapping
+To transform the error value to another domain before doing any computations on it, you can supply an `error_map` callback function to the PID. The callback function should take one argument which is the error from the setpoint. This can be used e.g. to get a degree value error in a yaw angle control with values between [-pi, pi):
+```python
+import math
+
+def pi_clip(angle):
+    if angle > 0:
+        if angle > math.pi:
+            return angle - 2*math.pi
+    else:
+        if angle < -math.pi:
+            return angle + 2*math.pi
+    return angle
+
+pid.error_map = pi_clip
+```
+
+## Tests
+Use the following to run tests:
+```
+tox
+```
+
+## License
+Licensed under the [MIT License](https://github.com/m-lundberg/simple-pid/blob/master/LICENSE.md).
+
+
+
+
+%package help
+Summary:	Development documents and examples for simple-pid
+Provides:	python3-simple-pid-doc
+%description help
+# simple-pid
+
+[![Travis](https://travis-ci.com/m-lundberg/simple-pid.svg?branch=master)](https://travis-ci.com/m-lundberg/simple-pid)
+[![PyPI](https://img.shields.io/pypi/v/simple-pid.svg)](https://pypi.org/project/simple-pid/)
+[![Read the Docs](https://img.shields.io/readthedocs/simple-pid.svg)](https://simple-pid.readthedocs.io/)
+[![License](https://img.shields.io/github/license/m-lundberg/simple-pid.svg)](https://github.com/m-lundberg/simple-pid/blob/master/LICENSE.md)
+[![Downloads](https://pepy.tech/badge/simple-pid)](https://pepy.tech/project/simple-pid)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+A simple and easy to use PID controller in Python. If you want a PID controller without external dependencies that just works, this is for you! The PID was designed to be robust with help from [Brett Beauregards guide](http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/).
+
+Usage is very simple:
+
+```python
+from simple_pid import PID
+pid = PID(1, 0.1, 0.05, setpoint=1)
+
+# Assume we have a system we want to control in controlled_system
+v = controlled_system.update(0)
+
+while True:
+    # Compute new output from the PID according to the systems current value
+    control = pid(v)
+
+    # Feed the PID output to the system and get its current value
+    v = controlled_system.update(control)
+```
+
+Complete API documentation can be found [here](https://simple-pid.readthedocs.io/en/latest/simple_pid.html#module-simple_pid.PID).
+
+## Installation
+To install, run:
+```
+pip install simple-pid
+```
+
+## Usage
+The `PID` class implements `__call__()`, which means that to compute a new output value, you simply call the object like this:
+```python
+output = pid(current_value)
+```
+
+### The basics
+The PID works best when it is updated at regular intervals. To achieve this, set `sample_time` to the amount of time there should be between each update and then call the PID every time in the program loop. A new output will only be calculated when `sample_time` seconds has passed:
+```python
+pid.sample_time = 0.01  # Update every 0.01 seconds
+
+while True:
+    output = pid(current_value)
+```
+
+To set the setpoint, ie. the value that the PID is trying to achieve, simply set it like this:
+```python
+pid.setpoint = 10
+```
+
+The tunings can be changed any time when the PID is running. They can either be set individually or all at once:
+```python
+pid.Ki = 1.0
+pid.tunings = (1.0, 0.2, 0.4)
+```
+
+To use the PID in [reverse mode](http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-direction/), meaning that an increase in the input leads to a decrease in the output (like when cooling for example), you can set the tunings to negative values:
+
+```python
+pid.tunings = (-1.0, -0.1, 0)
+```
+
+Note that all the tunings should have the same sign.
+
+In order to get output values in a certain range, and also to avoid [integral windup](https://en.wikipedia.org/wiki/Integral_windup) (since the integral term will never be allowed to grow outside of these limits), the output can be limited to a range:
+```python
+pid.output_limits = (0, 10)    # Output value will be between 0 and 10
+pid.output_limits = (0, None)  # Output will always be above 0, but with no upper bound
+```
+
+### Other features
+#### Auto mode
+To disable the PID so that no new values are computed, set auto mode to False:
+```python
+pid.auto_mode = False  # No new values will be computed when pid is called
+pid.auto_mode = True   # pid is enabled again
+```
+When disabling the PID and controlling a system manually, it might be useful to tell the PID controller where to start from when giving back control to it. This can be done by enabling auto mode like this:
+```python
+pid.set_auto_mode(True, last_output=8.0)
+```
+This will set the I-term to the value given to `last_output`, meaning that if the system that is being controlled was stable at that output value the PID will keep the system stable if started from that point, without any big bumps in the output when turning the PID back on.
+
+#### Observing separate components
+When tuning the PID, it can be useful to see how each of the components contribute to the output. They can be seen like this:
+```python
+p, i, d = pid.components  # The separate terms are now in p, i, d
+```
+
+#### Proportional on measurement
+To eliminate overshoot in certain types of systems, you can calculate the [proportional term directly on the measurement](http://brettbeauregard.com/blog/2017/06/introducing-proportional-on-measurement/) instead of the error. This can be enabled like this:
+```python
+pid.proportional_on_measurement = True
+```
+
+#### Error mapping
+To transform the error value to another domain before doing any computations on it, you can supply an `error_map` callback function to the PID. The callback function should take one argument which is the error from the setpoint. This can be used e.g. to get a degree value error in a yaw angle control with values between [-pi, pi):
+```python
+import math
+
+def pi_clip(angle):
+    if angle > 0:
+        if angle > math.pi:
+            return angle - 2*math.pi
+    else:
+        if angle < -math.pi:
+            return angle + 2*math.pi
+    return angle
+
+pid.error_map = pi_clip
+```
+
+## Tests
+Use the following to run tests:
+```
+tox
+```
+
+## License
+Licensed under the [MIT License](https://github.com/m-lundberg/simple-pid/blob/master/LICENSE.md).
+
+
+
+
+%prep
+%autosetup -n simple-pid-1.0.1
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-simple-pid -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.1-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..ce63365
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+60c580a6be3894cd4108d99b23179d47  simple-pid-1.0.1.tar.gz