fw.h

Go to the documentation of this file.

/* --COPYRIGHT--,BSD
 * Copyright (c) 2012, Texas Instruments Incorporated
 * All rights reserved.
 *
 * 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.
 * --/COPYRIGHT--*/
#ifndef _FW_H_
#define _FW_H_



// **************************************************************************
// the includes

#include "sw/modules/iqmath/src/32b/IQmathLib.h"
#include "sw/modules/types/src/types.h"




#ifdef __cplusplus
extern "C" {
#endif


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


#define FW_INC_DELTA                     (1000)


#define FW_DEC_DELTA                     (1000)


#define FW_NUM_ISR_TICKS_PER_CTRL_TICK   (10)


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

typedef struct _FW_Obj_
{
  uint32_t     numIsrTicksPerFwTick;   

  uint32_t     counter_fw;             
  
  _iq          delta_inc;              
  _iq          delta_dec;              

  _iq          refValue;               
  _iq          fbackValue;             

  _iq          output;                 
        
  _iq          outMin;                 
  _iq          outMax;                 
  
  bool       flag_enableFw;          
} FW_Obj;


typedef struct _FW_Obj_ *FW_Handle;


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


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


extern FW_Handle FW_init(void *pMemory, const size_t numBytes);


static inline void FW_getMinMax(FW_Handle fwHandle,_iq *pOutMin,_iq *pOutMax)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  *pOutMin = fw->outMin;
  *pOutMax = fw->outMax;

  return;
} // end of FW_getMinMax() function


static inline void FW_setMinMax(FW_Handle fwHandle,const _iq outMin,const _iq outMax)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->outMin = outMin;
  fw->outMax = outMax;

  return;
} // end of FW_setMinMax() function


static inline void FW_setDeltas(FW_Handle fwHandle, const _iq delta_inc, const _iq delta_dec)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->delta_inc = delta_inc;
  
  fw->delta_dec = delta_dec;
 
  return;
} // end of FW_setDeltas() function


static inline void FW_setNumIsrTicksPerFwTick(FW_Handle fwHandle, const uint32_t numIsrTicksPerFwTick)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->numIsrTicksPerFwTick = numIsrTicksPerFwTick;
 
  return;
} // end of FW_setNumIsrTicksPerFwTick() function


static inline uint32_t FW_getNumIsrTicksPerFwTick(FW_Handle fwHandle)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  return(fw->numIsrTicksPerFwTick);
} // end of FW_getNumIsrTicksPerFwTick() function


static inline void FW_clearCounter(FW_Handle fwHandle)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->counter_fw = 0;
 
  return;
} // end of FW_clearCounter() function


static inline void FW_incCounter(FW_Handle fwHandle)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->counter_fw++;
 
  return;
} // end of FW_incCounter() function


static inline uint32_t FW_getCounter(FW_Handle fwHandle)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  return(fw->counter_fw);
} // end of FW_getCounter() function


static inline void FW_setFlag_enableFw(FW_Handle fwHandle, const bool state)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->flag_enableFw = state;
  
  return;
} // end of FW_setFlag_enableFw() function


static inline bool FW_getFlag_enableFw(FW_Handle fwHandle)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  return(fw->flag_enableFw);
} // end of FW_getFlag_enableFw() function


static inline void FW_setOutput(FW_Handle fwHandle,const _iq output)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  fw->output = output;

  return;
} // end of FW_setOutput() function


static inline _iq FW_getOutput(FW_Handle fwHandle)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  return(fw->output);
} // end of FW_getOutput() function


static inline void FW_run(FW_Handle fwHandle,const _iq refValue,const _iq fbackValue,_iq *pOutValue)
{
  FW_Obj *fw = (FW_Obj *)fwHandle;

  _iq Error;
  _iq output = fw->output;
  _iq delta_inc = fw->delta_inc;
  _iq delta_dec = fw->delta_inc;


  Error = refValue - fbackValue;

  if(Error < 0)
    {
          output = output - delta_dec;                // Calculate the output for negative error
        }
  else if(Error > 0)
    {
          output = output + delta_inc;                // Calculate the output for positive error
        }
  
  output = _IQsat(output,fw->outMax,fw->outMin);  // Saturate the output

  fw->output = output;                            // store the output
  fw->refValue = refValue;
  fw->fbackValue = fbackValue;

  *pOutValue = output;

  return;
} // end of FW_run() function


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

#endif // end of _FW_H_ definition