float/ctrl.h

Go to the documentation of this file.

#ifndef _CTRL_H_
#define _CTRL_H_



// **************************************************************************
// the includes
#ifdef __TMS320C28XX_CLA__
#include "sw/modules/math/src/float/CLAmath.h"
#else
#include <math.h>
#endif


// drivers


// modules
#include "sw/modules/types/src/types.h"

#include "sw/modules/ctrl/src/float/ctrl_obj.h"
#include "sw/modules/ctrl/src/ctrl_states.h"
#include "sw/modules/motor/src/float/motor.h"
#include "sw/modules/pi/src/float/pi.h"
#include "sw/modules/user/src/float/userParams.h"


// solutions





#ifdef __cplusplus
extern "C" {
#endif


// **************************************************************************
// the defines


// **************************************************************************
// the typedefs


// **************************************************************************
// the globals


// **************************************************************************
// the function prototypes

static inline void CTRL_checkForErrors(CTRL_Handle handle)
{

  return;
} // end of CTRL_checkForErrors() function


static inline void CTRL_computePhasor(const float_t angle_rad,MATH_vec2 *pPhasor)
{

#ifdef __TMS320C28XX_CLA__
  pPhasor->value[0] = CLAcos_inline(angle_rad);
  pPhasor->value[1] = CLAsin_inline(angle_rad);
#else
  pPhasor->value[0] = (float_t)cos(angle_rad);
  pPhasor->value[1] = (float_t)sin(angle_rad);
#endif

  return;
} // end of CTRL_computePhasor() function


static inline void CTRL_disable(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_enable = false;

  return;
} // end of CTRL_disable() function


static inline void CTRL_enable(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_enable = true;

  return;
} // end of CTRL_enable() function


static inline float_t CTRL_getBWc_rps(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->BWc_rps);
} // end of CTRL_getBWc_rps() function


static inline float_t CTRL_getBWdelta(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->BWdelta);
} // end of CTRL_getBWdelta() function


static inline float_t CTRL_getKctrl_Wb_p_kgm2(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Kctrl_Wb_p_kgm2);
} // end of CTRL_getKctrl_Wb_p_kgm2() function


static inline float_t CTRL_getVd_sf(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Vd_sf);
} // end of CTRL_getVd_sf() function


static inline float_t CTRL_getMaxVsMag_V(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->maxVsMag_V);
} // end of CTRL_getMaxVsMag_V() function


static inline void CTRL_computeOutputLimits_Id(CTRL_Handle handle,
                                               float_t *outMin,float_t *outMax)
{
  float_t Vd_sf = CTRL_getVd_sf(handle);
  float_t maxVsMag_V = CTRL_getMaxVsMag_V(handle);
  float_t tmp = Vd_sf * maxVsMag_V;

  *outMin = -tmp;
  *outMax = tmp;

  return;
} // end of CTRL_computeOutputLimits_Id() function


static inline void CTRL_computeOutputLimits_Iq(CTRL_Handle handle,
                                               const float_t Vd_out_V,
                                               float_t *outMin,float_t *outMax)
{
  float_t maxVsMag_V = CTRL_getMaxVsMag_V(handle);

#ifdef __TMS320C28XX_CLA__
  float_t tmp = CLAsqrt_inline((maxVsMag_V * maxVsMag_V) - (Vd_out_V * Vd_out_V));
#else
  float_t tmp = (float_t)sqrt((maxVsMag_V * maxVsMag_V) - (Vd_out_V * Vd_out_V));
#endif

  *outMin = -tmp;
  *outMax = tmp;

  return;
} // end of CTRL_computeOutputLimits_Iq() function


static inline int_least16_t CTRL_getCount_current(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->counter_current);
} // end of CTRL_getCount_current() function


static inline int_least16_t CTRL_getCount_isr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->counter_isr);
} // end of CTRL_getCount_isr() function


static inline int_least16_t CTRL_getCount_speed(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->counter_speed);
} // end of CTRL_getCount_speed() function


static inline int_least32_t CTRL_getCount_state(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->counter_state);
} // end of CTRL_getCount_state() function


static inline float_t CTRL_getCtrlFreq_Hz(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->ctrlFreq_Hz);
} // end of CTRL_getCtrlFreq_Hz() function


static inline float_t CTRL_getCurrentCtrlPeriod_sec(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->currentCtrlPeriod_sec);
} // end of CTRL_getCurrentCtrlPeriod_sec() function


static inline float_t CTRL_getCtrlPeriod_sec(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->ctrlPeriod_sec);
} // end of CTRL_getCtrlPeriod_sec() function


static inline CTRL_ErrorCode_e CTRL_getErrorCode(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->errorCode);
} // end of CTRL_getErrorCode() function


static inline bool CTRL_getFlag_enable(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_enable);
} // end of CTRL_getFlag_enable() function


static inline bool CTRL_getFlag_enableCurrentCtrl(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_enableCurrentCtrl);
} // end of CTRL_getFlag_enableCurrentCtrl() function


static inline bool CTRL_getFlag_enableSpeedCtrl(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_enableSpeedCtrl);
} // end of CTRL_getFlag_enableSpeedCtrl() function


static inline bool CTRL_getFlag_resetInt_Id(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_resetInt_Id);
} // end of CTRL_getFlag_resetInt_Id() function


static inline bool CTRL_getFlag_resetInt_Iq(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_resetInt_Iq);
} // end of CTRL_getFlag_resetInt_Iq() function


static inline bool CTRL_getFlag_resetInt_spd(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_resetInt_spd);
} // end of CTRL_getFlag_resetInt_spd() function


static inline bool CTRL_getFlag_useZeroIq_ref(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_useZeroIq_ref);
} // end of CTRL_getFlag_useZeroIq_ref() function


static inline float_t CTRL_getId_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Idq_A.value[0]);
} // end of CTRL_getId_A() function


static inline float_t *CTRL_getId_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_A.value[0]));
} // end of CTRL_getId_A_addr() function


static inline float_t CTRL_getId_offset_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Idq_offset_A.value[0]);
} // end of CTRL_getId_offset_A() function


static inline float_t *CTRL_getId_offset_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_offset_A.value[0]));
} // end of CTRL_getId_offset_A_addr() function


static inline float_t CTRL_getId_ref_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Idq_ref_A.value[0]);
} // end of CTRL_getId_ref_A() function


static inline float_t *CTRL_getId_ref_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_ref_A.value[0]));
} // end of CTRL_getId_ref_A_addr() function


static inline void CTRL_getIdq_A(CTRL_Handle handle,MATH_vec2 *pIdq_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  pIdq_A->value[0] = obj->Idq_A.value[0];
  pIdq_A->value[1] = obj->Idq_A.value[1];

  return;
} // end of CTRL_getIdq_A() function


static inline MATH_vec2 *CTRL_getIdq_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_A));
} // end of CTRL_getIdq_A_addr() function


static inline void CTRL_getIdq_offset_A(CTRL_Handle handle,MATH_vec2 *pIdq_offset_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  pIdq_offset_A->value[0] = obj->Idq_offset_A.value[0];
  pIdq_offset_A->value[1] = obj->Idq_offset_A.value[1];

  return;
} // end of CTRL_getIdq_offset_A() function


static inline MATH_vec2 *CTRL_getIdq_offset_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_offset_A));
} // end of CTRL_getIdq_offset_A_addr() function


static inline void CTRL_getIdq_ref_A(CTRL_Handle handle,MATH_vec2 *pIdq_ref_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  pIdq_ref_A->value[0] = obj->Idq_ref_A.value[0];
  pIdq_ref_A->value[1] = obj->Idq_ref_A.value[1];

  return;
} // end of CTRL_getIdq_ref_A() function


static inline MATH_vec2 *CTRL_getIdq_ref_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_ref_A));
} // end of CTRL_getIdq_ref_A_addr() function


static inline float_t CTRL_getIq_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Idq_A.value[1]);
} // end of CTRL_getIq_A() function


static inline float_t *CTRL_getIq_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_A.value[1]));
} // end of CTRL_getIq_A_addr() function


static inline float_t CTRL_getIq_offset_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Idq_offset_A.value[1]);
} // end of CTRL_getIq_offset_A() function


static inline float_t *CTRL_getIq_offset_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_offset_A.value[1]));
} // end of CTRL_getIq_offset_A_addr() function


static inline float_t CTRL_getIq_ref_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Idq_ref_A.value[1]);
} // end of CTRL_getIq_ref_A() function


static inline float_t *CTRL_getIq_ref_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Idq_ref_A.value[1]));
} // end of CTRL_getIq_ref_A_addr() function


static inline float_t CTRL_getKi(CTRL_Handle handle,const CTRL_Type_e ctrlType)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  float_t Ki = (float_t)0.0;

  if(ctrlType == CTRL_Type_PI_spd)
    {
      Ki = obj->Ki_spd_ApHz;
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      Ki = obj->Ki_Id;
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      Ki = obj->Ki_Iq;
    }
  else
    {
      // do nothing as of now
      ;
    }

  return(Ki);
} // end of CTRL_getKi() function


static inline float_t CTRL_getKp(CTRL_Handle handle,const CTRL_Type_e ctrlType)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  float_t Kp = (float_t)0.0;

  if(ctrlType == CTRL_Type_PI_spd)
    {
      Kp = obj->Kp_spd_ApHz;
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      Kp = obj->Kp_Id_VpA;
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      Kp = obj->Kp_Iq_VpA;
    }
  else
    {
      // do nothing as of now
      ;
    }

  return(Kp);
} // end of CTRL_getKp() function


static inline void CTRL_getGains(CTRL_Handle handle,const CTRL_Type_e ctrlType,
                                 float_t *pKp,float_t *pKi)
{
  *pKp = CTRL_getKp(handle,ctrlType);
  *pKi = CTRL_getKi(handle,ctrlType);

  return;    
} // end of CTRL_getGains() function


static inline MOTOR_Type_e CTRL_getMotorType(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->motorParams.type);
} // end of CTRL_getMotorType() function


static inline int_least16_t CTRL_getNumCtrlTicksPerCurrentTick(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  
  return(obj->numCtrlTicksPerCurrentTick);
} // end of CTRL_getNumCtrlTicksPerCurrentTick() function


static inline int_least16_t CTRL_getNumCtrlTicksPerSpeedTick(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  
  return(obj->numCtrlTicksPerSpeedTick);
} // end of CTRL_getNumCtrlTicksPerSpeedTick() function


static inline int_least16_t CTRL_getNumIsrTicksPerCtrlTick(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  
  return(obj->numIsrTicksPerCtrlTick);
} // end of CTRL_getNumIsrTicksPerCtrlTick() function


static inline float_t CTRL_getRefValue(CTRL_Handle handle,const CTRL_Type_e ctrlType)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  float_t ref = (float_t)0.0;

  if(ctrlType == CTRL_Type_PI_spd)
    {
      ref = PI_getRefValue(obj->piHandle_spd);
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      ref = PI_getRefValue(obj->piHandle_Id);
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      ref = PI_getRefValue(obj->piHandle_Iq);
    }
  else
    {
      // do nothing as of now
      ;
    }

  return(ref);
} // end of CTRL_getRefValue() function


static inline float_t CTRL_getSpeed_fb_Hz(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->speed_fb_Hz);
} // end of CTRL_getSpeed_fb_Hz() function


static inline float_t CTRL_getSpeed_out_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->speed_out_A);
} // end of CTRL_getSpeed_out_A() function


static inline float_t *CTRL_getSpeed_out_A_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->speed_out_A));
} // end of CTRL_getSpeed_out_A_addr() function


static inline float_t CTRL_getSpeed_outMax_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->speed_outMax_A);
} // end of CTRL_getSpeed_outMax_A() function


static inline float_t CTRL_getSpeed_outMin_A(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->speed_outMin_A);
} // end of CTRL_getSpeed_outMin_A() function


static inline float_t CTRL_getSpeed_ref_Hz(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->speed_ref_Hz);
} // end of CTRL_getSpeed_ref_Hz() function


static inline float_t CTRL_getSpeedCtrlPeriod_sec(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->speedCtrlPeriod_sec);
} // end of CTRL_getSpeedCtrlPeriod_sec() function


static inline CTRL_State_e CTRL_getState(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->state);
} // end of CTRL_getState() function


static inline float_t CTRL_getUi(CTRL_Handle handle,const CTRL_Type_e ctrlType)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;
  float_t Ui = (float_t)0.0;

  if(ctrlType == CTRL_Type_PI_spd)
    {
      Ui = obj->Ui_spd_A;
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      Ui = obj->Ui_Id_V;
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      Ui = obj->Ui_Iq_V;
    }
  else
    {
      // do nothing as of now
      ;
    }

  return(Ui);
} // end of CTRL_getUi() function


static inline float_t CTRL_getVd_V(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Vdq_V.value[0]);
} // end of CTRL_getVd_V() function


static inline float_t *CTRL_getVd_V_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Vdq_V.value[0]));
} // end of CTRL_getVd_V_addr() function


static inline float_t CTRL_getVd_offset_V(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Vdq_offset_V.value[0]);
} // end of CTRL_getVd_offset_V() function


static inline float_t *CTRL_getVd_offset_V_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Vdq_offset_V.value[0]));
} // end of CTRL_getVd_offset_V_addr() function


static inline void CTRL_getVdq_V(CTRL_Handle handle,MATH_vec2 *pVdq_V)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  pVdq_V->value[0] = obj->Vdq_V.value[0];
  pVdq_V->value[1] = obj->Vdq_V.value[1];

  return;
} // end of CTRL_getVdq_V() function


static inline MATH_vec2 *CTRL_getVdq_V_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Vdq_V));
} // end of CTRL_getVdq_V_addr() function


static inline void CTRL_getVdq_offset_V(CTRL_Handle handle,MATH_vec2 *pVdq_offset_V)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  pVdq_offset_V->value[0] = obj->Vdq_offset_V.value[0];
  pVdq_offset_V->value[1] = obj->Vdq_offset_V.value[1];

  return;
} // end of CTRL_getVdq_offset_V() function


static inline MATH_vec2 *CTRL_getVdq_offset_V_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Vdq_offset_V));
} // end of CTRL_getVdq_offset_V_addr() function


extern void CTRL_getVersion(CTRL_Handle handle,CTRL_Version *pVersion);


static inline float_t CTRL_getVq_V(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Vdq_V.value[1]);
} // end of CTRL_getVq_V() function


static inline float_t *CTRL_getVq_V_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Vdq_V.value[1]));
} // end of CTRL_getVq_V_addr() function


static inline float_t CTRL_getVq_offset_V(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->Vdq_offset_V.value[1]);
} // end of CTRL_getVq_offset_V() function


static inline float_t *CTRL_getVq_offset_V_addr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(&(obj->Vdq_offset_V.value[1]));
} // end of CTRL_getVq_offset_V_addr() function


static inline int_least32_t CTRL_getWaitTime(CTRL_Handle handle,const CTRL_State_e state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->waitTimes[state]);
} // end of CTRL_getWaitTime() function


extern void CTRL_getWaitTimes(CTRL_Handle handle,int_least32_t *pWaitTimes);


static inline void CTRL_incrCounter_current(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  int_least16_t count = obj->counter_current;

  // increment the count
  count++;

  // limit to 0 to INT_LEAST16_MAX - 1
  if(count == INT_LEAST16_MAX)
    {
      count = 0;
    }

  // save the count value
  obj->counter_current = count;

  return;
} // end of CTRL_incrCounter_current() function


static inline void CTRL_incrCounter_isr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  int_least16_t count = obj->counter_isr;

  // increment the count
  count++;

  // limit to 0 to INT_LEAST16_MAX - 1
  if(count == INT_LEAST16_MAX)
    {
      count = 0;
    }

  // save the count value
  obj->counter_isr = count;

  return;
} // end of CTRL_incrCounter_isr() function


static inline void CTRL_incrCounter_speed(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  int_least16_t count = obj->counter_speed;

  // increment the count
  count++;

  // limit to 0 to INT_LEAST16_MAX - 1
  if(count == INT_LEAST16_MAX)
    {
      count = 0;
    }

  // save the count value
  obj->counter_speed = count;

  return;
} // end of CTRL_incrCounter_speed() function


static inline void CTRL_incrCounter_state(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  int_least32_t count = obj->counter_state;

  // increment the count
  count++;

  // limit to 0 to INT_LEAST32_MAX - 1
  if(count == INT_LEAST32_MAX)
    {
      count = 0;
    }

  // save the count value
  obj->counter_state = count;

  return;
} // end of CTRL_incrCounter_state() function


extern CTRL_Handle CTRL_init(void *pMemory,const size_t numBytes);


static inline bool CTRL_isEnabled(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  return(obj->flag_enable);
} // end of CTRL_isEnabled() function


static inline bool CTRL_isError(CTRL_Handle handle)
{
  CTRL_State_e ctrlState = CTRL_getState(handle);
  bool state = false;


  // check for controller errors
  if(ctrlState == CTRL_State_Error)
    {
      state = true;
    }

  return(state);
} // end of CTRL_isError() function


static inline bool CTRL_isIdle(CTRL_Handle handle)
{
  CTRL_State_e state = CTRL_getState(handle);
  bool result = false;

  if(state == CTRL_State_Idle)
    {
      result = true;
    }
  
  return(result);
} // end of CTRL_isIdle() function


static inline bool CTRL_isNotIdle(CTRL_Handle handle)
{
  CTRL_State_e state = CTRL_getState(handle);
  bool result = true;

  if(state == CTRL_State_Idle)
    {
      result = false;
    }
  
  return(result);
} // end of CTRL_isNotIdle() function


extern void CTRL_reset(CTRL_Handle handle);


static inline void CTRL_resetCounter_current(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->counter_current = 0;

  return;
} // end of CTRL_resetCounter_current() function


static inline void CTRL_resetCounter_isr(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->counter_isr = 0;

  return;
} // end of CTRL_resetCounter_isr() function


static inline void CTRL_resetCounter_speed(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->counter_speed = 0;

  return;
} // end of CTRL_resetCounter_speed() function


static inline void CTRL_resetCounter_state(CTRL_Handle handle)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->counter_state = 0;

  return;
} // end of CTRL_resetCounter_state() function


static inline void CTRL_setBWc_rps(CTRL_Handle handle,const float_t BWc_rps)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->BWc_rps = BWc_rps;

  return;
} // end of CTRL_setBWc_rps() function


static inline void CTRL_setBWdelta(CTRL_Handle handle,const float_t BWdelta)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->BWdelta = BWdelta;

  return;
} // end of CTRL_setBWdelta() function


static inline void CTRL_setCtrlFreq_Hz(CTRL_Handle handle,const float_t ctrlFreq_Hz)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->ctrlFreq_Hz = ctrlFreq_Hz;

  return;
} // end of CTRL_setCtrlFreq_Hz() function


static inline void CTRL_setCtrlPeriod_sec(CTRL_Handle handle,const float_t ctrlPeriod_sec)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->ctrlPeriod_sec = ctrlPeriod_sec;

  return;
} // end of CTRL_setCtrlPeriod_sec() function


static inline void CTRL_setCurrentCtrlPeriod_sec(CTRL_Handle handle,const float_t currentCtrlPeriod_sec)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->currentCtrlPeriod_sec = currentCtrlPeriod_sec;

  return;
} // end of CTRL_setCurrentCtrlPeriod_sec() function


static inline void CTRL_setErrorCode(CTRL_Handle handle,const CTRL_ErrorCode_e errorCode)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->errorCode = errorCode;

  return;
} // end of CTRL_setErrorCode() function


static inline void CTRL_setFlag_enable(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_enable = state;

  return;
} // end of CTRL_setFlag_enable() function


static inline void CTRL_setFlag_enableCurrentCtrl(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_enableCurrentCtrl = state;

  return;
} // end of CTRL_setFlag_enableCurrentCtrl() function


static inline void CTRL_setFlag_enableSpeedCtrl(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_enableSpeedCtrl = state;

  return;
} // end of CTRL_setFlag_enableSpeedCtrl() function


static inline void CTRL_setFlag_resetInt_Id(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_resetInt_Id = state;

  return;
} // end of CTRL_setFlag_resetInt_Id() function


static inline void CTRL_setFlag_resetInt_Iq(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_resetInt_Iq = state;

  return;
} // end of CTRL_setFlag_resetInt_Iq() function


static inline void CTRL_setFlag_resetInt_spd(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_resetInt_spd = state;

  return;
} // end of CTRL_setFlag_resetInt_spd() function


static inline void CTRL_setFlag_useZeroIq_ref(CTRL_Handle handle,const bool state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->flag_useZeroIq_ref = state;

  return;
} // end of CTRL_setFlag_userZeroIq_ref() function


static inline void CTRL_setId_A(CTRL_Handle handle,const float_t Id_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_A.value[0] = Id_A;

  return;
} // end of CTRL_setId_A() function


static inline void CTRL_setId_offset_A(CTRL_Handle handle,const float_t Id_offset_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_offset_A.value[0] = Id_offset_A;

  return;
} // end of CTRL_setId_offset_A() function


static inline void CTRL_setId_ref_A(CTRL_Handle handle,const float_t Id_ref_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_ref_A.value[0] = Id_ref_A;

  return;
} // end of CTRL_setId_ref_A() function


static inline void CTRL_setIdq_A(CTRL_Handle handle,const MATH_vec2 *pIdq_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_A.value[0] = pIdq_A->value[0];
  obj->Idq_A.value[1] = pIdq_A->value[1];

  return;
} // end of CTRL_setIdq_A() function


static inline void CTRL_setIdq_offset_A(CTRL_Handle handle,const MATH_vec2 *pIdq_offset_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_offset_A.value[0] = pIdq_offset_A->value[0];
  obj->Idq_offset_A.value[1] = pIdq_offset_A->value[1];

  return;
} // end of CTRL_setIdq_offset_A() function


static inline void CTRL_setIdq_ref_A(CTRL_Handle handle,const MATH_vec2 *pIdq_ref_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_ref_A.value[0] = pIdq_ref_A->value[0];
  obj->Idq_ref_A.value[1] = pIdq_ref_A->value[1];

  return;
} // end of CTRL_setIdq_ref_A() function


static inline void CTRL_setIq_A(CTRL_Handle handle,const float_t Iq_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_A.value[1] = Iq_A;

  return;
} // end of CTRL_setIq_A() function


static inline void CTRL_setIq_offset_pu(CTRL_Handle handle,const float_t Iq_offset_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_offset_A.value[1] = Iq_offset_A;

  return;
} // end of CTRL_setIq_offset_A() function


static inline void CTRL_setIq_ref_A(CTRL_Handle handle,const float_t Iq_ref_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Idq_ref_A.value[1] = Iq_ref_A;

  return;
} // end of CTRL_setIq_ref_A() function


static inline void CTRL_setKctrl_Wb_p_kgm2(CTRL_Handle handle,const float_t Kctrl_Wb_p_kgm2)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Kctrl_Wb_p_kgm2 = Kctrl_Wb_p_kgm2;

  return;
} // end of CTRL_setKctrl_Wb_p_kgm2() function


static inline void CTRL_setKi(CTRL_Handle handle,const CTRL_Type_e ctrlType,const float_t Ki)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  if(ctrlType == CTRL_Type_PI_spd)
    {
      obj->Ki_spd_ApHz = Ki;
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      obj->Ki_Id = Ki;
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      obj->Ki_Iq = Ki;
    }
  else
    {
      // do nothing as of now
      ;
    }

  return;
} // end of CTRL_setKi() function


static inline void CTRL_setKp(CTRL_Handle handle,const CTRL_Type_e ctrlType,const float_t Kp)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  if(ctrlType == CTRL_Type_PI_spd)
    {
      obj->Kp_spd_ApHz = Kp;
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      obj->Kp_Id_VpA = Kp;
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      obj->Kp_Iq_VpA = Kp;
    }
  else
    {
      // do nothing as of now
      ;
    }

  return;
} // end of CTRL_setKp() function


static inline void CTRL_setGains(CTRL_Handle handle,const CTRL_Type_e ctrlType,
                                 const float_t Kp,const float_t Ki)
{
  CTRL_setKp(handle,ctrlType,Kp);
  CTRL_setKi(handle,ctrlType,Ki);

  return;    
} // end of CTRL_setGains() function


static inline void CTRL_setMaxVsMag_V(CTRL_Handle handle,const float_t maxVsMag_V)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->maxVsMag_V = maxVsMag_V;

  return;
} // end of CTRL_setMaxVsMag_V() function


static inline void CTRL_setMotorParams(CTRL_Handle handle,
                                       const MOTOR_Type_e motorType,
                                       const uint_least16_t numPolePairs,
                                       const float_t ratedFlux_Wb,
                                       const float_t Ls_d_H,
                                       const float_t Ls_q_H,
                                       const float_t Rs_d_Ohm,
                                       const float_t Rs_q_Ohm,
                                       const float_t Rr_d_Ohm,
                                       const float_t Rr_q_Ohm)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->motorParams.type = motorType;
  obj->motorParams.numPolePairs = numPolePairs;
  obj->motorParams.ratedFlux_Wb = ratedFlux_Wb;
  obj->motorParams.Ls_d_H = Ls_d_H;
  obj->motorParams.Ls_q_H = Ls_q_H;
  obj->motorParams.Rs_d_Ohm = Rs_d_Ohm;
  obj->motorParams.Rs_q_Ohm = Rs_q_Ohm;
  obj->motorParams.Rr_d_Ohm = Rr_d_Ohm;
  obj->motorParams.Rr_q_Ohm = Rr_q_Ohm;

  return;
} // end of CTRL_setMotorParams() function


static inline void CTRL_setNumCtrlTicksPerCurrentTick(CTRL_Handle handle,
                                                      const int_least16_t numCtrlTicksPerCurrentTick)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->numCtrlTicksPerCurrentTick = numCtrlTicksPerCurrentTick;

  return;
} // end of CTRL_setNumCtrlTicksPerCurrentTick() function


static inline void CTRL_setNumCtrlTicksPerSpeedTick(CTRL_Handle handle,
                                                    const int_least16_t numCtrlTicksPerSpeedTick)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->numCtrlTicksPerSpeedTick = numCtrlTicksPerSpeedTick;

  return;
} // end of CTRL_setNumCtrlTicksPerSpeedTick() function


static inline void CTRL_setNumIsrTicksPerCtrlTick(CTRL_Handle handle,
                                                  const int_least16_t numIsrTicksPerCtrlTick)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->numIsrTicksPerCtrlTick = numIsrTicksPerCtrlTick;

  return;
} // end of CTRL_setNumIsrTicksPerCtrlTick() function


extern void CTRL_setParams(CTRL_Handle handle,USER_Params *pUserParams);


static inline void CTRL_setSpeed_fb_Hz(CTRL_Handle handle,const float_t speed_fb_Hz)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->speed_fb_Hz = speed_fb_Hz;

  return;
} // end of CTRL_setSpeed_fb_pu() function


static inline void CTRL_setSpeed_out_A(CTRL_Handle handle, const float_t speed_out_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->speed_out_A = speed_out_A;

  return;
} // end of CTRL_setSpeed_out_A() function


static inline void CTRL_setSpeed_outMax_A(CTRL_Handle handle,const float_t speed_outMax_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->speed_outMax_A = speed_outMax_A;

  return;
} // end of CTRL_setSpeed_outMax_A() function


static inline void CTRL_setSpeed_outMin_A(CTRL_Handle handle,const float_t speed_outMin_A)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->speed_outMin_A = speed_outMin_A;

  return;
} // end of CTRL_setSpeed_outMin_A() function


static inline void CTRL_setSpeed_ref_Hz(CTRL_Handle handle,const float_t speed_ref_Hz)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->speed_ref_Hz = speed_ref_Hz;

  return;
} // end of CTRL_setSpeed_ref_Hz() function


static inline void CTRL_setSpeedCtrlPeriod_sec(CTRL_Handle handle,const float_t speedCtrlPeriod_sec)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->speedCtrlPeriod_sec = speedCtrlPeriod_sec;

  return;
} // end of CTRL_setSpeedCtrlPeriod_sec() function


static inline void CTRL_setState(CTRL_Handle handle,const CTRL_State_e state)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->prevState = obj->state;
  obj->state = state;

  return;
} // end of CTRL_setState() function


static inline void CTRL_setUi(CTRL_Handle handle,const CTRL_Type_e ctrlType,const float_t Ui)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;


  if(ctrlType == CTRL_Type_PI_spd)
    {
      obj->Ui_spd_A = Ui;

      CTRL_setFlag_resetInt_spd(handle,true);
    }
  else if(ctrlType == CTRL_Type_PI_Id)
    {
      obj->Ui_Id_V = Ui;

      CTRL_setFlag_resetInt_Id(handle,true);
    }
  else if(ctrlType == CTRL_Type_PI_Iq)
    {
      obj->Ui_Iq_V = Ui;

      CTRL_setFlag_resetInt_Iq(handle,true);
    }
  else
    {
      // do nothing as of now
      ;
    }

  return;
} // end of CTRL_setUi() function


static inline void CTRL_setVd_sf(CTRL_Handle handle,const float_t Vd_sf)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Vd_sf = Vd_sf;

  return;
} // end of CTRL_setVd_sf() function


static inline void CTRL_setVdq_V(CTRL_Handle handle,const MATH_vec2 *pVdq_V)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Vdq_V.value[0] = pVdq_V->value[0];
  obj->Vdq_V.value[1] = pVdq_V->value[1];

  return;
} // end of CTRL_setVdq_V() function


static inline void CTRL_setVdq_offset_V(CTRL_Handle handle,const MATH_vec2 *pVdq_offset_V)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;

  obj->Vdq_offset_V.value[0] = pVdq_offset_V->value[0];
  obj->Vdq_offset_V.value[1] = pVdq_offset_V->value[1];

  return;
} // end of CTRL_setVdq_offset_V() function


// TEMP
extern void CTRL_setVersion(CTRL_Handle handle,
                            const CTRL_TargetProc_e targetProc,
                            const uint16_t majorReleaseNumber,
                            const uint16_t minorReleaseNumber);


extern void CTRL_setWaitTimes(CTRL_Handle handle,const int_least32_t *pWaitTimes);


extern bool CTRL_updateState(CTRL_Handle handle);


static inline void CTRL_setup(CTRL_Handle handle,
                              const float_t speed_ref_Hz,
                              const float_t speed_fb_Hz,
                              const MATH_vec2 *pIdq_A,
                              const MATH_vec2 *pIdq_offset_A,
                              const MATH_vec2 *pVdq_offset_V,
                              const bool flag_enableSpeedCtrl,
                              const bool flag_enableCurrentCtrl,
                              const bool flag_useZeroIq_ref)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;


  // set the input values
  CTRL_setSpeed_ref_Hz(handle,speed_ref_Hz);
  CTRL_setSpeed_fb_Hz(handle,speed_fb_Hz);

  CTRL_setIdq_A(handle,pIdq_A);
  CTRL_setIdq_offset_A(handle,pIdq_offset_A);
  CTRL_setVdq_offset_V(handle,pVdq_offset_V);

  CTRL_setFlag_enableSpeedCtrl(handle,flag_enableSpeedCtrl);
  CTRL_setFlag_enableCurrentCtrl(handle,flag_enableCurrentCtrl);
  CTRL_setFlag_useZeroIq_ref(handle,flag_useZeroIq_ref);


  // if needed, reset the Id integrator
  if(CTRL_getFlag_resetInt_Id(handle))
    {
      float_t Ui = CTRL_getUi(handle,CTRL_Type_PI_Id);

      // set the new integrator value
      PI_setUi(obj->piHandle_Id,Ui);

      // reset the flag
      CTRL_setFlag_resetInt_Id(handle,false);
    }


  // if needed, reset the Iq integrator
  if(CTRL_getFlag_resetInt_Iq(handle))
    {
      float_t Ui = CTRL_getUi(handle,CTRL_Type_PI_Iq);

      // set the new integrator value
      PI_setUi(obj->piHandle_Iq,Ui);

      // reset the flag
      CTRL_setFlag_resetInt_Iq(handle,false);
    }


  // if needed, reset the speed integrator
  if(CTRL_getFlag_resetInt_spd(handle))
    {
      float_t Ui = CTRL_getUi(handle,CTRL_Type_PI_spd);

      // set the new integrator value
      PI_setUi(obj->piHandle_spd,Ui);

      // reset the flag
      CTRL_setFlag_resetInt_spd(handle,false);
    }


  // update the Kp gains
  PI_setKp(obj->piHandle_Id,CTRL_getKp(handle,CTRL_Type_PI_Id));
  PI_setKp(obj->piHandle_Iq,CTRL_getKp(handle,CTRL_Type_PI_Iq));
  PI_setKp(obj->piHandle_spd,CTRL_getKp(handle,CTRL_Type_PI_spd));


  // update the Ki gains
  PI_setKi(obj->piHandle_Id,CTRL_getKi(handle,CTRL_Type_PI_Id));
  PI_setKi(obj->piHandle_Iq,CTRL_getKi(handle,CTRL_Type_PI_Iq));
  PI_setKi(obj->piHandle_spd,CTRL_getKi(handle,CTRL_Type_PI_spd));


  // increment the counters
  CTRL_incrCounter_current(handle);
  CTRL_incrCounter_speed(handle);

  return;
} // end of CTRL_setup() function


static inline void CTRL_run(CTRL_Handle handle,MATH_vec2 *pVdq_V)
{
  CTRL_Obj *obj = (CTRL_Obj *)handle;


  // when appropriate, run the PI speed controller
  if(CTRL_getFlag_enableSpeedCtrl(handle))
    {
     int_least16_t count = CTRL_getCount_speed(handle);
     int_least16_t numCtrlTicksPerSpeedTick = CTRL_getNumCtrlTicksPerSpeedTick(handle);

     if(count >= numCtrlTicksPerSpeedTick)
       {
         float_t refValue_Hz = CTRL_getSpeed_ref_Hz(handle);
         float_t fbackValue_Hz = CTRL_getSpeed_fb_Hz(handle);
         float_t ffwdValue_A = (float_t)0.0;
         float_t outMax_A = CTRL_getSpeed_outMax_A(handle);
         float_t outMin_A = CTRL_getSpeed_outMin_A(handle);

         // reset the speed count
         CTRL_resetCounter_speed(handle);

         // set the minimum and maximum values
         PI_setMinMax(obj->piHandle_spd,outMin_A,outMax_A);

         // run the speed controller
         PI_run_series(obj->piHandle_spd,refValue_Hz,fbackValue_Hz,ffwdValue_A,CTRL_getSpeed_out_A_addr(handle));
       }
    }
  else
    {
      // zero the speed output value
      CTRL_setSpeed_out_A(handle,0.0);
    }


  // when appropriate, run the PI Id and Iq controllers
  if(CTRL_getFlag_enableCurrentCtrl(handle))
    {
     int_least16_t count = CTRL_getCount_current(handle);
     int_least16_t numCtrlTicksPerCurrentTick = CTRL_getNumCtrlTicksPerCurrentTick(handle);

     if(count >= numCtrlTicksPerCurrentTick)
       {
         float_t refValue_A;
         float_t fbackValue_A;
         float_t ffwdValue_V;
         float_t outMin_V,outMax_V;
         

         // reset the current count
         CTRL_resetCounter_current(handle);


         // ***********************************
         // configure and run the Id controller

         // get the reference value
         refValue_A = CTRL_getId_offset_A(handle);

         // get the feedback value
         fbackValue_A = CTRL_getId_A(handle);

         // get the feedforward value
         ffwdValue_V = CTRL_getVd_offset_V(handle);

         // compute the Id output limits
         CTRL_computeOutputLimits_Id(handle,&outMin_V,&outMax_V);

         // set the minimum and maximum values
         PI_setMinMax(obj->piHandle_Id,outMin_V,outMax_V);

         // run the Id PI controller
         PI_run_series(obj->piHandle_Id,refValue_A,fbackValue_A,ffwdValue_V,&(pVdq_V->value[0]));

         // store the Id reference value
         CTRL_setId_ref_A(handle,refValue_A);


         // ***********************************
         // configure and run the Iq controller

         // compute the reference value
         if(CTRL_getFlag_enableSpeedCtrl(handle))
           {
             if(CTRL_getFlag_useZeroIq_ref(handle))
               {
                 refValue_A = 0.0;
               }
             else
               {
                 refValue_A = CTRL_getSpeed_out_A(handle) + CTRL_getIq_offset_A(handle);
               }
           }
         else
           {
             // get the Iq offset value
             refValue_A = CTRL_getIq_offset_A(handle);
           }

         // get the feedback value
         fbackValue_A = CTRL_getIq_A(handle);

         // get the feedforward value
         ffwdValue_V = CTRL_getVq_offset_V(handle);

         // compute the Iq output limits
         CTRL_computeOutputLimits_Iq(handle,pVdq_V->value[0],&outMin_V,&outMax_V);

         // set the minimum and maximum values
         PI_setMinMax(obj->piHandle_Iq,outMin_V,outMax_V);

         // run the Iq PI controller
         PI_run_series(obj->piHandle_Iq,refValue_A,fbackValue_A,ffwdValue_V,&(pVdq_V->value[1]));

         // store the Iq reference value
         CTRL_setIq_ref_A(handle,refValue_A);
       }
     else
       {
         CTRL_getVdq_V(handle,pVdq_V);
       }
   }
 else
   {
     pVdq_V->value[0] = 0.0;
     pVdq_V->value[1] = 0.0;
   }


 // store the Vdq value
 CTRL_setVdq_V(handle,pVdq_V);


 // increment the state counter
  CTRL_incrCounter_state(handle);

 return;
} // end of CTRL_run() function


#ifdef __cplusplus
}
#endif // extern "C"


#endif // end of _CTRL_H_ definition