py-feedback-controller 0.1.0__tar.gz

py_feedback_controller-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrik-J
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_feedback_controller-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include include *.hpp *.h

py_feedback_controller-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: py-feedback-controller
+Version: 0.1.0
+License-File: LICENSE
+Dynamic: license-file

py_feedback_controller-0.1.0/include/pyfc/fc_exceptions.hpp

@@ -0,0 +1,24 @@
+#ifndef FC_EXCEPTIONS_HPP
+#define FC_EXCEPTIONS_HPP
+
+#include <exception>
+
+class FeedbackControllerException : public std::exception {
+    public:
+        FeedbackControllerException(const char* msg);
+        virtual const char* what() const throw();
+
+    private:
+        const char* msg;
+};
+
+class VectorMathException : public std::exception {
+    public:
+        VectorMathException(const char* msg);
+        virtual const char* what() const throw();
+
+    private:
+        const char* msg;
+};
+
+#endif

py_feedback_controller-0.1.0/include/pyfc/feedbackcontroller.hpp

@@ -0,0 +1,36 @@
+#ifndef FEEDBACKCONTROLLER_HPP
+#define FEEDBACKCONTROLLER_HPP
+
+#include <sstream>
+
+#include "fc_exceptions.hpp"
+#include "fc_math.hpp"
+
+enum FCType {
+    NotDefined,
+    PID,
+    AutoOptPID
+};  
+
+class FeedbackController {
+    public:
+        FeedbackController();
+        FeedbackController(FCType type);
+        FeedbackController(FCType type, double setpoint);
+
+        virtual double requestLoop(double input) = 0;
+        virtual void init() = 0;
+
+        void setSetpoint(double setpoint);
+        double getSetpoint() const;
+        FCType getType() const;
+
+        friend std::ostream& operator<<(std::ostream& strm, const FeedbackController& fc);
+
+    protected:
+        FCType type;
+        double setpoint = 0.0;
+        bool intialized = false;
+};
+
+#endif 

py_feedback_controller-0.1.0/include/pyfc/math/fc_math.hpp

@@ -0,0 +1,29 @@
+#ifndef FC_MATH_HPP
+#define FC_MATH_HPP
+
+#include <vector>
+#include <cmath>
+#include <random>
+
+#include "fc_exceptions.hpp"
+
+using DoubleVector = std::vector<double>;
+
+DoubleVector operator+(DoubleVector& v1, DoubleVector& v2);
+DoubleVector operator-(DoubleVector& v1, DoubleVector& v2);
+double operator*(DoubleVector& v1, DoubleVector& v2);
+DoubleVector operator*(DoubleVector& v, double& d);
+DoubleVector operator*(double& d, DoubleVector& v);
+DoubleVector operator/(DoubleVector& v, double& d);
+
+DoubleVector& operator+=(DoubleVector& v1, DoubleVector& v2);
+DoubleVector& operator-=(DoubleVector& v1, DoubleVector& v2);
+DoubleVector& operator*=(DoubleVector& v, double& d);
+DoubleVector& operator/=(DoubleVector& v, double& d);
+
+double abs(DoubleVector& v);
+double sign(double d);
+
+DoubleVector randomVector(unsigned int length, double mean = 5.0, double std_dev = 2.0);
+
+#endif

py_feedback_controller-0.1.0/include/pyfc/pid/autooptpid.hpp

@@ -0,0 +1,58 @@
+#ifndef AUTOOPTPID_HPP
+#define AUTOOPTPID_HPP
+
+#include "feedbackcontroller.hpp"
+#include "pidcontroller.hpp"
+
+class AutoOptimizingPID : public FeedbackController {
+    static inline const unsigned int MAX_STORED = 3;
+
+    public:
+        AutoOptimizingPID();
+        AutoOptimizingPID(DoubleVector initialParams, double setpoint, double lr = 1e-3);
+        AutoOptimizingPID(double setpoint, double lr = 1e-3);
+        ~AutoOptimizingPID();
+
+        double requestLoop(double input) override;
+        void init() override;
+
+        void setLearningRate(double lr);
+        double getLearningRate();
+
+        void setCaps(double time_integral, double derivative);
+        DoubleVector getCaps();
+
+        PIDController getAsPIDController();
+
+    private:
+        // param 0: proportional gain
+        // param 1: integral gain
+        // param 2: derivative gain
+        DoubleVector params;
+
+        // learning rate for gradient descent
+        double lr = 1e-3;
+
+        // storage for integral and derivative
+        double* last_points;
+        double* last_times;
+        unsigned int last_input_index = 0;
+
+        // time integral
+        double time_integral = 0.0;
+        double ti_cap = 0.0;    // to prevent overshooting
+
+        // derivative
+        double derivative = 0.0;
+        double dv_cap = 0.0;    // to prevent overshooting
+
+        // timer for time steps
+        Timer timer;
+
+        // functions
+        void integrate();
+        void differentiate();
+        void optimize();
+};
+
+#endif

py_feedback_controller-0.1.0/include/pyfc/pid/pidcontroller.hpp

@@ -0,0 +1,52 @@
+#ifndef PIDCONTROLLER_HPP
+#define PIDCONTROLLER_HPP
+
+#include "feedbackcontroller.hpp"
+#include "timer.hpp"
+
+class PIDController : public FeedbackController {
+    
+    static inline const unsigned int MAX_STORED = 5;
+    
+    public:
+        PIDController();
+        PIDController(DoubleVector params, double setpoint);
+        ~PIDController();
+
+        double requestLoop(double input) override;
+        void init() override;
+
+        void setCaps(double time_integral, double derivative);
+        DoubleVector getCaps();
+
+        void setGains(DoubleVector gains);
+        DoubleVector getGains();
+
+    private:
+        // param 0: proportional gain
+        // param 1: integral gain
+        // param 2: derivative gain
+        DoubleVector params;
+
+        // storage for integral and derivative
+        double* last_points;
+        double* last_times;
+        unsigned int last_input_index = 0;
+
+        // time integral
+        double time_integral = 0.0;
+        double ti_cap = 0.0;    // to prevent overshooting
+
+        // derivative
+        double derivative = 0.0;
+        double dv_cap = 0.0;    // to prevent overshooting
+
+        // timer for time steps
+        Timer timer;
+
+        // functions
+        void integrate();
+        void differentiate();
+};
+
+#endif

py_feedback_controller-0.1.0/include/pyfc/timer/timer.hpp

@@ -0,0 +1,19 @@
+#ifndef TIMER_HPP
+#define TIMER_HPP
+
+#include <chrono>
+
+class Timer {
+    public:
+        Timer();
+
+        void start();
+        uint64_t currentMillis();
+        uint64_t currentMicros();
+
+    private:
+        std::chrono::steady_clock::time_point start_time;
+
+};
+
+#endif

py_feedback_controller-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_feedback_controller-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+from setuptools import setup, find_packages
+
+ext_modules = [
+    Pybind11Extension("pyfc._core", 
+                      ["src/pyfc/fc_exceptions.cpp",
+                       "src/pyfc/feedbackcontroller.cpp", 
+                       "src/pyfc/math/fc_math.cpp", 
+                       "src/pyfc/pid/pidcontroller.cpp", 
+                       "src/pyfc/pid/autooptpid.cpp", 
+                       "src/pyfc/timer/timer.cpp", 
+                       "src/pyfc/_core.cpp"], 
+                      include_dirs=[
+                                    "include",
+                                    "include/pyfc", 
+                                    "include/pyfc/math", 
+                                    "include/pyfc/timer", 
+                                    "include/pyfc/pid"],
+                      cxx_std=17),
+]
+
+setup(
+    name="py-feedback-controller",
+    version="0.1.0",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    ext_modules=ext_modules, 
+    cmdclass={"build_ext": build_ext})

py_feedback_controller-0.1.0/src/py_feedback_controller.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: py-feedback-controller
+Version: 0.1.0
+License-File: LICENSE
+Dynamic: license-file

py_feedback_controller-0.1.0/src/py_feedback_controller.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+include/pyfc/fc_exceptions.hpp
+include/pyfc/feedbackcontroller.hpp
+include/pyfc/math/fc_math.hpp
+include/pyfc/pid/autooptpid.hpp
+include/pyfc/pid/pidcontroller.hpp
+include/pyfc/timer/timer.hpp
+src/pyfc/_core.cpp
+src/pyfc/fc_exceptions.cpp
+src/pyfc/feedbackcontroller.cpp
+src/pyfc/math/fc_math.cpp
+src/pyfc/pid/autooptpid.cpp
+src/pyfc/pid/pidcontroller.cpp
+src/pyfc/timer/timer.cpp
+src/py_feedback_controller.egg-info/PKG-INFO
+src/py_feedback_controller.egg-info/SOURCES.txt
+src/py_feedback_controller.egg-info/dependency_links.txt
+src/py_feedback_controller.egg-info/top_level.txt
+src/pyfc/__init__.py
+src/pyfc/_core.cpp
+src/pyfc/_core.pyi
+src/pyfc/fc_exceptions.cpp
+src/pyfc/feedbackcontroller.cpp
+src/pyfc/math/fc_math.cpp
+src/pyfc/pid/__init__.py
+src/pyfc/pid/autooptpid.cpp
+src/pyfc/pid/pidcontroller.cpp
+src/pyfc/timer/__init__.py
+src/pyfc/timer/timer.cpp
+test/test.py

py_feedback_controller-0.1.0/src/py_feedback_controller.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_feedback_controller-0.1.0/src/py_feedback_controller.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyfc

py_feedback_controller-0.1.0/src/pyfc/__init__.py

@@ -0,0 +1,11 @@
+from pyfc import pid, timer
+from pyfc._core import VectorMathException, FeedbackControllerException
+
+__all__ = [
+    "pid",
+    "timer",
+    "VectorMathException",
+    "FeedbackControllerException"
+]
+
+__version__ = "0.1.0"

py_feedback_controller-0.1.0/src/pyfc/_core.cpp

@@ -0,0 +1,58 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "feedbackcontroller.hpp"
+#include "timer/timer.hpp"
+#include "pid/pidcontroller.hpp"
+#include "pid/autooptpid.hpp"
+#include "fc_exceptions.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_core, m) {
+    m.doc() = "Bindings for the PyFC module.";
+
+    // exceptions
+    static py::exception<FeedbackControllerException> fc_exc(m, "FeedbackControllerException");
+    static py::exception<VectorMathException> vm_exc(m, "VectorMathException");
+
+
+    // Timer class
+    py::class_<Timer>(m, "Timer")
+    .def(py::init(), "Create an instance of the Timer class")
+    .def("start", &Timer::start, "Set the start time of the timer.")
+    .def("millis", &Timer::currentMillis, "Get the milliseconds since the timer was started")
+    .def("micros", &Timer::currentMicros, "Get the microseconds since the timer was started");
+
+    // base FeedbackController class
+    py::class_<FeedbackController>(m, "FeedbackController")
+    .def("setSetpoint", &FeedbackController::setSetpoint, py::arg("setpoint"), "Set the setpoint of the feedback controller.")
+    .def("getSetpoint", &FeedbackController::getSetpoint, "Get the setpoint of the feedback controller.")
+    .def("__repr__", [](const FeedbackController &self) {
+        std::ostringstream oss;
+        oss << self;
+        return oss.str();
+    });
+
+    // PIDController class
+    py::class_<PIDController, FeedbackController>(m, "PIDController")
+    .def(py::init<DoubleVector, double>(), py::arg("params"), py::arg("setpoint"))
+    .def("requestLoop", &PIDController::requestLoop, py::arg("input"), "Request a single loop of the PID controller.")
+    .def("init", &PIDController::init, "Initialize the PID controller")
+    .def("setCaps", &PIDController::setCaps, py::arg("time_integral"), py::arg("derivative"), "Set the upper and lower caps of the integral and derivative.")
+    .def("getCaps", &PIDController::getCaps, "Get the upper and lower caps of the integral and derivative.")
+    .def("setGains", &PIDController::setGains, py::arg("gains"),"Set the parameter gains of the PID controller.")
+    .def("getGains", &PIDController::getGains, "Get the parameter gains of the PID controller.");
+
+    // AutoOptimizingPID class
+    py::class_<AutoOptimizingPID, FeedbackController>(m, "AutoOptimizingPID")
+    .def(py::init<DoubleVector, double, double>(), py::arg("params"), py::arg("setpoint"), py::arg("lr") = 1e-3)
+    .def(py::init<double, double>(), py::arg("setpoint"), py::arg("lr") = 1e-3)
+    .def("requestLoop", &AutoOptimizingPID::requestLoop, py::arg("input"), "Request a single loop of the auto-optimizing PID controller.")
+    .def("init", &AutoOptimizingPID::init, "Initialize the auto-optimizing PID controller")
+    .def("setCaps", &AutoOptimizingPID::setCaps, py::arg("time_integral"), py::arg("derivative"), "Set the upper and lower caps of the integral and derivative.")
+    .def("getCaps", &AutoOptimizingPID::getCaps, "Get the upper and lower caps of the integral and derivative.")
+    .def("setLearningRate", &AutoOptimizingPID::setLearningRate, py::arg("lr"), "Set the learning rate of the gradient descent algorithm.")
+    .def("getLearningRate", &AutoOptimizingPID::getLearningRate, "Get the learning rate of the gradient descent algorithm.")
+    .def("getAsPID", &AutoOptimizingPID::getAsPIDController, "Get the auto-optimizing PID controller as a simple PID controller.");
+};

py_feedback_controller-0.1.0/src/pyfc/_core.pyi

@@ -0,0 +1,101 @@
+"""
+Bindings for the PyFC module.
+"""
+from __future__ import annotations
+import collections.abc
+import typing
+__all__: list[str] = ['AutoOptimizingPID', 'FeedbackController', 'FeedbackControllerException', 'PIDController', 'Timer', 'VectorMathException']
+class AutoOptimizingPID(FeedbackController):
+    @typing.overload
+    def __init__(self, params: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], setpoint: typing.SupportsFloat | typing.SupportsIndex, lr: typing.SupportsFloat | typing.SupportsIndex = 0.001) -> None:
+        ...
+    @typing.overload
+    def __init__(self, setpoint: typing.SupportsFloat | typing.SupportsIndex, lr: typing.SupportsFloat | typing.SupportsIndex = 0.001) -> None:
+        ...
+    def getAsPID(self) -> PIDController:
+        """
+        Get the auto-optimizing PID controller as a simple PID controller.
+        """
+    def getCaps(self) -> list[float]:
+        """
+        Get the upper and lower caps of the integral and derivative.
+        """
+    def getLearningRate(self) -> float:
+        """
+        Get the learning rate of the gradient descent algorithm.
+        """
+    def init(self) -> None:
+        """
+        Initialize the auto-optimizing PID controller
+        """
+    def requestLoop(self, input: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        """
+        Request a single loop of the auto-optimizing PID controller.
+        """
+    def setCaps(self, time_integral: typing.SupportsFloat | typing.SupportsIndex, derivative: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        """
+        Set the upper and lower caps of the integral and derivative.
+        """
+    def setLearningRate(self, lr: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        """
+        Set the learning rate of the gradient descent algorithm.
+        """
+class FeedbackController:
+    def __repr__(self) -> str:
+        ...
+    def getSetpoint(self) -> float:
+        """
+        Get the setpoint of the feedback controller.
+        """
+    def setSetpoint(self, setpoint: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        """
+        Set the setpoint of the feedback controller.
+        """
+class FeedbackControllerException(Exception):
+    pass
+class PIDController(FeedbackController):
+    def __init__(self, params: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex], setpoint: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        ...
+    def getCaps(self) -> list[float]:
+        """
+        Get the upper and lower caps of the integral and derivative.
+        """
+    def getGains(self) -> list[float]:
+        """
+        Get the parameter gains of the PID controller.
+        """
+    def init(self) -> None:
+        """
+        Initialize the PID controller
+        """
+    def requestLoop(self, input: typing.SupportsFloat | typing.SupportsIndex) -> float:
+        """
+        Request a single loop of the PID controller.
+        """
+    def setCaps(self, time_integral: typing.SupportsFloat | typing.SupportsIndex, derivative: typing.SupportsFloat | typing.SupportsIndex) -> None:
+        """
+        Set the upper and lower caps of the integral and derivative.
+        """
+    def setGains(self, gains: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex]) -> None:
+        """
+        Set the parameter gains of the PID controller.
+        """
+class Timer:
+    def __init__(self) -> None:
+        """
+        Create an instance of the Timer class
+        """
+    def micros(self) -> int:
+        """
+        Get the microseconds since the timer was started
+        """
+    def millis(self) -> int:
+        """
+        Get the milliseconds since the timer was started
+        """
+    def start(self) -> None:
+        """
+        Set the start time of the timer.
+        """
+class VectorMathException(Exception):
+    pass

py_feedback_controller-0.1.0/src/pyfc/fc_exceptions.cpp

@@ -0,0 +1,13 @@
+#include "fc_exceptions.hpp"
+
+FeedbackControllerException::FeedbackControllerException(const char* msg) : msg(msg) {};
+
+const char* FeedbackControllerException::what() const throw() {
+    return this->msg;
+};
+
+VectorMathException::VectorMathException(const char* msg) : msg(msg) {};
+
+const char* VectorMathException::what() const throw() {
+    return this->msg;
+};

py_feedback_controller-0.1.0/src/pyfc/feedbackcontroller.cpp

@@ -0,0 +1,39 @@
+#include "feedbackcontroller.hpp"
+
+FeedbackController::FeedbackController() : type(FCType::NotDefined) {};
+
+FeedbackController::FeedbackController(FCType type) : type(type) {};
+
+FeedbackController::FeedbackController(FCType type, double setpoint) : type(type), setpoint(setpoint) {};
+
+void FeedbackController::setSetpoint(double setpoint) {
+    this->setpoint = setpoint;
+};
+
+double FeedbackController::getSetpoint() const {
+    return this->setpoint;
+};
+
+FCType FeedbackController::getType() const {
+    return this->type;
+};
+
+std::ostream& operator<<(std::ostream& strm, const FeedbackController& fc) {
+    strm << "Feedback controller of type ";
+    switch (fc.getType()) {
+        case FCType::PID:
+            strm << "'PID'";
+            break;
+        case FCType::AutoOptPID:
+            strm << "'Auto-Optimizing PID'";
+            break;
+        case FCType::NotDefined:
+            strm << "'Undefined'";
+            break;
+        default:
+            strm << "'Unknown'";
+            break;
+    }
+    strm << " with setpoint " << fc.getSetpoint() << std::endl;
+    return strm;
+};

py_feedback_controller-0.1.0/src/pyfc/math/fc_math.cpp

@@ -0,0 +1,101 @@
+#include "fc_math.hpp"
+
+DoubleVector operator+(DoubleVector& v1, DoubleVector& v2) {
+    if (v1.size() != v2.size())
+        throw VectorMathException("Vector of unequal size cannot be used in a mathematical operation!");
+    DoubleVector v;
+    for (unsigned int i = 0; i < v1.size(); i++)   
+        v.push_back(v1[0] + v2[0]);
+    return v;
+};
+
+DoubleVector operator-(DoubleVector& v1, DoubleVector& v2) {
+    if (v1.size() != v2.size())
+        throw VectorMathException("Vector of unequal size cannot be used in a mathematical operation!");
+    DoubleVector v;
+    for (unsigned int i = 0; i < v1.size(); i++)   
+        v.push_back(v1[0] - v2[0]);
+    return v;
+};
+
+double operator*(DoubleVector& v1, DoubleVector& v2) {
+    if (v1.size() != v2.size())
+        throw VectorMathException("Vector of unequal size cannot be used in a mathematical operation!");
+    double scalar = 0.0;
+    for (unsigned int i = 0; i < v1.size(); i++)   
+        scalar += v1[0] + v2[0];
+    return scalar;
+};
+
+DoubleVector operator*(DoubleVector& v, double& d) {
+    DoubleVector v_scaled;
+    for (unsigned int i = 0; i < v.size(); i++)   
+        v_scaled.push_back(v[0] * d);
+    return v_scaled;
+};
+
+DoubleVector operator*(double& d, DoubleVector& v) {
+    return v * d;
+};
+
+DoubleVector operator/(DoubleVector& v, double& d) {
+    double s = 1/d;
+    return v * s;
+}; 
+
+DoubleVector& operator+=(DoubleVector& v1, DoubleVector& v2) {
+    if (v1.size() != v2.size())
+        throw VectorMathException("Vector of unequal size cannot be used in a mathematical operation!");
+    for (unsigned int i = 0; i < v1.size(); i++) 
+        v1[i] += v2[i];
+    return v1;
+};
+
+DoubleVector& operator-=(DoubleVector& v1, DoubleVector& v2) {
+    if (v1.size() != v2.size())
+        throw VectorMathException("Vector of unequal size cannot be used in a mathematical operation!");
+    for (unsigned int i = 0; i < v1.size(); i++) 
+        v1[i] -= v2[i];
+    return v1;
+};
+
+DoubleVector& operator*=(DoubleVector& v, double& d) {
+    for (unsigned int i = 0; i < v.size(); i++) 
+        v[i] *= d;
+    return v;
+};
+
+DoubleVector& operator/=(DoubleVector& v, double& d) {
+    for (unsigned int i = 0; i < v.size(); i++) 
+        v[i] /= d;
+    return v;
+};
+
+double abs(DoubleVector& v) {
+    double sum = 0.0;
+    for (unsigned int i = 0; i < v.size(); i++) 
+        sum += std::pow(v[i], 2.0);
+    return std::pow(sum, 0.5);
+};
+
+double sign(double d) {
+    if (d >= 0.0) 
+        return 1.0;
+    else
+        return -1.0;
+};
+
+DoubleVector randomVector(unsigned int length, double mean, double std_dev) {
+    DoubleVector v(length, 0.0);
+
+    std::random_device rd{};
+    std::mt19937 gen{rd()};
+    std::normal_distribution d{mean, std_dev};
+
+    auto random = [&d, &gen]{ return d(gen); };
+
+    for (unsigned int i = 0; i < length; i++)
+        v[i] = random();
+
+    return v;
+};

py_feedback_controller-0.1.0/src/pyfc/pid/__init__.py

@@ -0,0 +1,4 @@
+from .._core import PIDController, AutoOptimizingPID
+
+# Re-export classes
+__all__ = ["PIDController", "AutoOptimizingPID"]

py_feedback_controller-0.1.0/src/pyfc/pid/autooptpid.cpp

@@ -0,0 +1,153 @@
+#include "autooptpid.hpp"
+
+AutoOptimizingPID::AutoOptimizingPID() : FeedbackController(FCType::AutoOptPID) {};
+
+AutoOptimizingPID::AutoOptimizingPID(DoubleVector initialParams, double setpoint, double lr) : FeedbackController(FCType::AutoOptPID, setpoint) {
+    this->params = initialParams;
+    this->lr = lr;
+};
+
+AutoOptimizingPID::AutoOptimizingPID(double setpoint, double lr) : FeedbackController(FCType::AutoOptPID, setpoint) {
+    this->lr = lr;
+};
+
+AutoOptimizingPID::~AutoOptimizingPID() {
+    delete[] this->last_points;
+    delete[] this->last_times;
+};
+
+double AutoOptimizingPID::requestLoop(double input) {   
+    if (!this->intialized) 
+        throw FeedbackControllerException("Feedback controller was not initialized! Use .init()");
+    
+    // get the difference to use in the PID loop
+    double diff = input - this->setpoint;
+
+    // get the next index
+    unsigned int lii = (this->last_input_index + 1) % AutoOptimizingPID::MAX_STORED;
+    
+    // store the new point
+    this->last_points[lii] = diff;
+    this->last_times[lii] = this->timer.currentMicros();
+    this->last_input_index = lii;
+
+    // sum of all three parts
+    double sum = 0.0;
+
+    // proportional
+    sum += this->params[0] * diff;
+
+    // integral
+    this->integrate();
+    sum += this->params[1] * this->time_integral;
+
+    // derivative
+    this->differentiate();
+    sum += this->params[2] * this->derivative;
+
+    // prior to the next step, optimize the params
+    this->optimize();
+
+    // return the sum
+    return sum;
+};
+
+void AutoOptimizingPID::init() {
+    this->timer = Timer();
+    this->timer.start();
+    this->last_points = new double[AutoOptimizingPID::MAX_STORED] {0.0};
+    this->last_times = new double[AutoOptimizingPID::MAX_STORED] {0.0};
+    this->last_input_index = 0;
+
+    if (this->params.size() == 0)
+        this->params = randomVector(3);
+    this->intialized = true;
+};
+
+void AutoOptimizingPID::setLearningRate(double lr) {
+    this->lr = lr;
+};
+
+double AutoOptimizingPID::getLearningRate() {
+    return this->lr;
+};
+
+void AutoOptimizingPID::setCaps(double time_integral, double derivative) {
+    this->ti_cap = time_integral;
+    this->dv_cap = derivative;
+};
+
+DoubleVector AutoOptimizingPID::getCaps() {
+    return {this->ti_cap, this->dv_cap};
+};
+
+PIDController AutoOptimizingPID::getAsPIDController() {
+    PIDController pid(this->params, this->setpoint);
+    return pid;
+};
+
+void AutoOptimizingPID::integrate() {
+    double dt = this->last_times[this->last_input_index] - this->last_times[(AutoOptimizingPID::MAX_STORED + this->last_input_index - 1) % AutoOptimizingPID::MAX_STORED];
+    double dI = (this->last_points[this->last_input_index] + this->last_points[(AutoOptimizingPID::MAX_STORED + this->last_input_index - 1) % AutoOptimizingPID::MAX_STORED]) / 2.0;
+
+    this->time_integral += dt * dI;
+
+    if (std::abs(this->time_integral) > this->ti_cap) 
+        this->time_integral = sign(this->time_integral) * this->ti_cap;
+};
+
+void AutoOptimizingPID::differentiate() {
+    // three-point central difference formula
+    unsigned int lii = this->last_input_index;
+    unsigned int li = (AutoOptimizingPID::MAX_STORED + lii - 1) % AutoOptimizingPID::MAX_STORED;
+    unsigned int l = (AutoOptimizingPID::MAX_STORED + li - 1) % AutoOptimizingPID::MAX_STORED;
+    
+    // t_i+1 - t-i
+    double h1 = this->last_times[lii] - this->last_times[li];  
+    
+    // t_i - t_i-1
+    double h2 = this->last_times[li] - this->last_times[l];
+
+    // simple fail-safe, if dt = 0 
+    if (h1 == 0) 
+        h1 = 1e-20;
+    if (h2 == 0)
+        h2 = 1e-20;
+    
+    // y_i
+    double I0 = this->last_points[lii];
+    
+    // y_i-1
+    double I1 = this->last_points[li];
+    
+    // y_i-2
+    double I2 = this->last_points[l];
+
+    double coeff0 = (2 * h1 + h2)/(h1 * (h1 + h2));
+    double coeff1 = (h1 + h2)/(h1 * h2);
+    double coeff2 = h1/(h2 * (h1 + h2));
+
+    this->derivative = coeff0 * I0 + coeff1 * I1 + coeff2 * I2;
+    
+    if (std::abs(this->derivative) > this->dv_cap) 
+        this->derivative = sign(this->derivative) * this->dv_cap;
+};
+
+void AutoOptimizingPID::optimize() {
+    // determine the error between the setpoint and the input
+    double diff = this->last_points[this->last_input_index];
+    double error = 0.5*std::pow(diff, 2);
+
+    // gradient
+    DoubleVector grad;
+    
+    // the derivatives wrt. to each parameter
+    grad.push_back(diff);
+    grad.push_back(this->time_integral);
+    grad.push_back(this->derivative);
+
+    grad *= diff;
+
+    // gradient descent
+    this->params -= this->lr * grad;
+};

py_feedback_controller-0.1.0/src/pyfc/pid/pidcontroller.cpp

@@ -0,0 +1,124 @@
+#include "pidcontroller.hpp"
+
+PIDController::PIDController() : FeedbackController(FCType::PID) {};
+
+PIDController::PIDController(DoubleVector params, double setpoint) : FeedbackController(FCType::PID, setpoint) {
+    this->params = params;
+};
+
+PIDController::~PIDController() {
+    delete[] this->last_points;
+    delete[] this->last_times;
+};
+
+double PIDController::requestLoop(double input) {
+    if (this->params.size() != 3)
+        throw FeedbackControllerException("PID params were not set!");
+    
+    if (!this->intialized) 
+        throw FeedbackControllerException("Feedback controller was not initialized! Use .init()");
+
+    // get the difference to use in the PID loop
+    double diff = input - this->setpoint;
+
+    // get the next index
+    unsigned int lii = (this->last_input_index + 1) % PIDController::MAX_STORED;
+    
+    // store the new point
+    this->last_points[lii] = diff;
+    this->last_times[lii] = this->timer.currentMicros();
+    this->last_input_index = lii;
+
+    // sum of all three partsw
+    double sum = 0.0;
+
+    // proportional
+    sum += this->params[0] * diff;
+
+    // integral
+    this->integrate();
+    sum += this->params[1] * this->time_integral;
+
+    // derivative
+    this->differentiate();
+    sum += this->params[2] * this->derivative;
+
+    // return the sum
+    return sum;
+};
+
+void PIDController::integrate() {
+    double dt = this->last_times[this->last_input_index] - this->last_times[(PIDController::MAX_STORED + this->last_input_index - 1) % PIDController::MAX_STORED];
+    double dI = (this->last_points[this->last_input_index] + this->last_points[(PIDController::MAX_STORED + this->last_input_index - 1) % PIDController::MAX_STORED])/2.0;
+
+    this->time_integral += dt * dI;
+
+    if (abs(this->time_integral) > this->ti_cap) 
+        this->time_integral = sign(this->time_integral) * this->ti_cap;
+};
+
+void PIDController::differentiate() {
+    // three-point central difference formula
+    unsigned int lii = this->last_input_index;
+    unsigned int li = (PIDController::MAX_STORED + lii - 1) % PIDController::MAX_STORED;
+    unsigned int l = (PIDController::MAX_STORED + li - 1) % PIDController::MAX_STORED;
+    
+    // t_i+1 - t-i
+    double h1 = this->last_times[lii] - this->last_times[li];  
+    
+    // t_i - t_i-1
+    double h2 = this->last_times[li] - this->last_times[l];
+
+    // simple fail-safe, if dt = 0 
+    if (h1 == 0) 
+        h1 = 1e-20;
+    if (h2 == 0)
+        h2 = 1e-20;
+    
+    // y_i
+    double I0 = this->last_points[lii];
+    
+    // y_i-1
+    double I1 = this->last_points[li];
+    
+    // y_i-2
+    double I2 = this->last_points[l];
+
+    double coeff0 = (2 * h1 + h2)/(h1 * (h1 + h2));
+    double coeff1 = (h1 + h2)/(h1 * h2);
+    double coeff2 = h1/(h2 * (h1 + h2));
+
+    this->derivative = coeff0 * I0 + coeff1 * I1 + coeff2 * I2;
+    
+    if (abs(this->derivative) > this->dv_cap) 
+        this->derivative = sign(this->derivative) * this->dv_cap;
+};
+
+void PIDController::init() {
+    this->timer = Timer();
+    this->timer.start();
+    this->last_points = new double[PIDController::MAX_STORED] {0.0};
+    this->last_times = new double[PIDController::MAX_STORED] {0.0};
+    this->last_input_index = 0;
+
+    if (this->params.size() == 0)
+        this->params = randomVector(3);
+    this->intialized = true;
+};
+
+void PIDController::setCaps(double time_integral, double derivative) {
+    this->ti_cap = time_integral;
+    this->dv_cap = derivative;
+};
+
+DoubleVector PIDController::getCaps() {
+    return {this->ti_cap, this->dv_cap};
+};
+
+void PIDController::setGains(DoubleVector gains) {
+    this->params = gains;
+};
+
+DoubleVector PIDController::getGains() {
+    return this->params;
+};

py_feedback_controller-0.1.0/src/pyfc/timer/__init__.py

@@ -0,0 +1,4 @@
+from .._core import Timer
+
+# Re-export classes
+__all__ = ["Timer"]

py_feedback_controller-0.1.0/src/pyfc/timer/timer.cpp

@@ -0,0 +1,23 @@
+#include "timer.hpp"
+
+Timer::Timer() {};
+
+void Timer::start() {
+    this->start_time = std::chrono::steady_clock::now();
+};
+
+uint64_t Timer::currentMicros() {
+    const auto now = std::chrono::steady_clock::now();
+
+    auto diff = std::chrono::duration_cast<std::chrono::microseconds>(now - this->start_time);    
+
+    return diff.count();
+};
+
+uint64_t Timer::currentMillis() {
+    const auto now = std::chrono::steady_clock::now();
+
+    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(now - this->start_time);    
+
+    return diff.count();
+};

py_feedback_controller-0.1.0/test/test.py

@@ -0,0 +1,46 @@
+from pyfc.pid import AutoOptimizingPID
+
+from matplotlib.animation import FuncAnimation
+from matplotlib import pyplot as plt
+
+import numpy as np
+
+setpoint = 1.0
+
+pid = AutoOptimizingPID(setpoint=setpoint, lr=1.0)
+pid.init()
+
+z = [0.0]
+t = [0.0]
+dt = 1e-3
+
+fig, ax = plt.subplots()  
+line = ax.plot(t, z)[0]
+        
+def func(frame):
+    global setpoint
+    if (frame % 500) == 0:
+        if setpoint == 1.0:
+            setpoint = 2.0
+        elif setpoint == 2.0:
+            setpoint = 1.5
+        elif setpoint == 1.5:
+            setpoint = 2.5
+        elif setpoint == 2.5:
+            setpoint = 1.0
+                
+    pid.setSetpoint(setpoint)        
+    
+    pid_out = pid.requestLoop(z[frame-1])
+    
+    z.append(z[frame-1] + dt * pid_out)
+    t.append(t[frame-1] + dt)
+
+    line.set_xdata(t)
+    line.set_ydata(z)
+    ax.set_ylim(-0.1, 1.2*np.max(z))
+    ax.set_xlim(0, 1.2*np.max(t))
+    
+anim = FuncAnimation(fig, func, frames=10000, interval=1)
+plt.grid()
+plt.show()