/home/jgoppert/Projects/ap/libraries/PID/PID.h

Go to the documentation of this file.

// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: t -*-


#ifndef PID_h
#define PID_h

#include <stdint.h>
#include <AP_EEPROMB.h>

class PID {
public:
        // EEProm Storage Type
        enum storage_t
        {
                STORE_OFF,
                STORE_EEPROM_FLOAT,
                STORE_EEPROM_UINT16
        } _storage;

        PID() :
                _storage(STORE_OFF),
                _address(0),
                _gain_array(&_local_gains[0])
        {}

        PID(uint16_t address, storage_t storage = STORE_EEPROM_UINT16) :
                _storage(storage),
                _address(address),
                _gain_array(&_local_gains[0])
        {
                load_gains();
        }

        
        PID(float *gain_array) :
                _storage(STORE_OFF),
                _gain_array(gain_array)
        {
        }

        long    get_pid(int32_t error, uint16_t dt, float scaler = 1.0);

        void    reset_I() {     
                _integrator = 0; 
                _last_error = 0; 
                _last_derivative = 0;
        }

        void    load_gains();

        void    save_gains();


        float   kP()                                    { return _gain_array[0]; }
        float   kI()                                    { return _gain_array[1]; }
        float   kD()                                    { return _gain_array[2]; }
        float   imax()                                  { return _gain_array[3]; }

        void    kP(const float v)               { _gain_array[0] = v; }
        void    kI(const float v)               { _gain_array[1] = v; }
        void    kD(const float v)               { _gain_array[2] = v; }
        void    imax(const float v);
        
        void    address(const uint16_t v)       { _address = v; }
        
        // one-shot operator for setting all of the gain properties at once
        //void operator ()(const float p, const float i, const float d, const float max)
        //{ kP(p); kI(i); kD(d); imax(max); }
        
        float   get_integrator()                { return _integrator; }

private:
        AP_EEPROMB      _ee;
        uint16_t        _address;                       
        float           *_gain_array;           

        float           _local_gains[4];        

        float           _integrator;            
        int32_t         _last_error;            
        float           _last_derivative;       

        static const uint8_t _RC = 20; 
};

#endif