pi.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2024 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef PI_H
#define PI_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include "dcl.h"
#include <stdlib.h>
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef struct _PI_Obj_
{
    DCL_PI cntlr;                
    float32_t refValue;          
    float32_t fbackValue;        
    float32_t ffwdValue;         
} PI_Obj;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef struct _PI_Obj_ *PI_Handle;
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getFbackValue(PI_Handle handle)
{
    return(handle->fbackValue);
} // end of PI_getFbackValue() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getFfwdValue(PI_Handle handle)
{
    return(handle->ffwdValue);
} // end of PI_getFfwdValue() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_getGains(PI_Handle handle, float32_t *pKp, float32_t *pKi)
{
    *pKp = handle->cntlr.Kp;
    *pKi = handle->cntlr.Ki;
} // end of PI_getGains() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getKi(PI_Handle handle)
{
    return(handle->cntlr.Ki);
} // end of PI_getKi() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getKp(PI_Handle handle)
{
    return(handle->cntlr.Kp);
} // end of PI_getKp() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_getMinMax(PI_Handle handle, float32_t *pOutMin, float32_t *pOutMax)
{
    *pOutMin = handle->cntlr.Umin;
    *pOutMax = handle->cntlr.Umax;
} // end of PI_getMinMax() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getOutMax(PI_Handle handle)
{
    return(handle->cntlr.Umax);
} // end of PI_getOutMax() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getOutMin(PI_Handle handle)
{
    return(handle->cntlr.Umin);
} // end of PI_getOutMin() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getRefValue(PI_Handle handle)
{
    return(handle->refValue);
} // end of PI_getRefValue() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline float32_t
PI_getUi(PI_Handle handle)
{
    return(handle->cntlr.i10);
} // end of PI_getUi() function
 
//*****************************************************************************
//
//
//*****************************************************************************
extern PI_Obj*
PI_init(void *pMemory, const size_t numBytes);
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setFbackValue(PI_Handle handle, const float32_t fbackValue)
{
    handle->fbackValue = fbackValue;
 
    return;
} // end of PI_setFbackValue() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setFfwdValue(PI_Handle handle, const float32_t ffwdValue)
{
    handle->ffwdValue = ffwdValue;
 
    return;
} // end of PI_setFfwdValue() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setGains(PI_Handle handle, const float32_t Kp, const float32_t Ki)
{
    handle->cntlr.Kp = Kp;
    handle->cntlr.Ki = Ki;
} // end of PI_setGains() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setKi(PI_Handle handle, const float32_t Ki)
{
    handle->cntlr.Ki = Ki;
} // end of PI_setKi() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setKp(PI_Handle handle, const float32_t Kp)
{
    handle->cntlr.Kp = Kp;
} // end of PI_setKp() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setMinMax(PI_Handle handle, const float32_t outMin, const float32_t outMax)
{
    handle->cntlr.Umin = outMin;
    handle->cntlr.Umax = outMax;
} // end of PI_setMinMax() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setOutMax(PI_Handle handle, const float32_t outMax)
{
    handle->cntlr.Umax = outMax;
} // end of PI_setOutMax() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setOutMin(PI_Handle handle, const float32_t outMin)
{
    handle->cntlr.Umin = outMin;
} // end of PI_setOutMin() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setRefValue(PI_Handle handle, const float32_t refValue)
{
    handle->refValue = refValue;
 
    return;
} // end of PI_setRefValue() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_setUi(PI_Handle handle, const float32_t Ui)
{
    handle->cntlr.i10 = Ui;
} // end of PI_setUi() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_run_parallel(PI_Handle handle, const float32_t refValue,
                const float32_t fbackValue, const float32_t ffwdValue,
                float32_t *pOutValue)
{
    handle->cntlr.i10 += ffwdValue;
    *pOutValue = DCL_runPIParallel(&handle->cntlr, refValue, fbackValue);
 
    PI_setRefValue(handle,refValue);
    PI_setFbackValue(handle,fbackValue);
    PI_setFfwdValue(handle,ffwdValue);
} // end of PI_run_parallel() function
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_run_series(PI_Handle handle, const float32_t refValue,
              const float32_t fbackValue, const float32_t ffwdValue,
              float32_t *pOutValue)
{
    handle->cntlr.i10 += ffwdValue;
    *pOutValue = DCL_runPISeries(&handle->cntlr, refValue, fbackValue);
 
    PI_setRefValue(handle,refValue);
    PI_setFbackValue(handle,fbackValue);
    PI_setFfwdValue(handle,ffwdValue);
} // end of PI_run_series() function
 
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
PI_run(PI_Handle handle, const float32_t refValue,
       const float32_t fbackValue, float32_t *pOutValue)
{
    *pOutValue = DCL_runPISeries(&handle->cntlr, refValue, fbackValue);
} // end of PI_run_series() function
 
#ifdef __cplusplus
}
#endif
 
#endif // end of PI_H defines