fem.h

Go to the documentation of this file.

#ifndef _FEM_H_
#define _FEM_H_



// **************************************************************************
// the includes
#include <math.h>

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






#ifdef __cplusplus
extern "C" {
#endif


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


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

typedef struct _FEM_Obj_
{
  uint32_t          timerPeriod_cnts;      
  uint32_t          cnt_z0;                
  uint32_t          cnt_z1;                
  uint32_t          deltaCnt;              

  uint32_t          maxDeltaCnt;           
  uint32_t          minDeltaCnt;           

  uint32_t          maxDeltaCntObserved;   
  
  uint32_t          errorCnt;              

  bool            flag_freqError;        
} FEM_Obj;


typedef struct _FEM_Obj_ *FEM_Handle;


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


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


static inline uint32_t FEM_getCnt_z0(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->cnt_z0);
} // end of FEM_getCnt_z0() function


static inline uint32_t FEM_getCnt_z1(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->cnt_z1);
} // end of FEM_getCnt_z1() function


static inline uint32_t FEM_getDeltaCnt(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->deltaCnt);
} // end of FEM_getDeltaCnt() function


static inline uint32_t FEM_getErrorCnt(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->errorCnt);
} // end of FEM_getErrorCnt() function


static inline bool FEM_getFlag_freqError(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->flag_freqError);
} // end of FEM_getFlag_freqError() function


static inline uint32_t FEM_getMaxDeltaCnt(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->maxDeltaCnt);
} // end of FEM_getMaxDeltaCnt() function


static inline uint32_t FEM_getMaxDeltaCntObserved(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->maxDeltaCntObserved);
} // end of FEM_getMaxDeltaCntObserved() function


static inline uint32_t FEM_getMinDeltaCnt(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->minDeltaCnt);
} // end of FEM_getMinDeltaCnts() function


static inline uint32_t FEM_getTimerPeriod(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->timerPeriod_cnts);
} // end of FEM_getTimerPeriod() function


extern FEM_Handle FEM_init(void *pMemory,const size_t numBytes);


static inline bool FEM_isFreqError(FEM_Handle handle)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  return(obj->flag_freqError);
} // end of FEM_isFreqError() function


static inline void FEM_setCnt_z0(FEM_Handle handle,const uint32_t cnt)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->cnt_z0 = cnt;

  return;
} // end of FEM_setCnt_z0() function


static inline void FEM_setCnt_z1(FEM_Handle handle,const uint32_t cnt)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->cnt_z1 = cnt;

  return;
} // end of FEM_setCnt_z1() function


static inline void FEM_setDeltaCnt(FEM_Handle handle,const uint32_t deltaCnt)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->deltaCnt = deltaCnt;

  return;
} // end of FEM_setDeltaCnt() function


static inline void FEM_setErrorCnt(FEM_Handle handle,const uint32_t numErrors)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->errorCnt = numErrors;

  return;
} // end of FEM_setErrorCnt() function


static inline void FEM_setFlag_freqError(FEM_Handle handle,const bool state)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->flag_freqError = state;

  return;
} // end of FEM_setFlag_freqError() function


static inline void FEM_setMaxDeltaCnt(FEM_Handle handle,const uint32_t maxDeltaCnt)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->maxDeltaCnt = maxDeltaCnt;

  return;
} // end of FEM_setMaxDeltaCnt() function


static inline void FEM_setMaxDeltaCntObserved(FEM_Handle handle,const uint32_t maxDeltaCnt)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->maxDeltaCntObserved = maxDeltaCnt;

  return;
} // end of FEM_setMaxDeltaCntObserved() function


static inline void FEM_setMinDeltaCnt(FEM_Handle handle,const uint32_t minDeltaCnt)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->minDeltaCnt = minDeltaCnt;

  return;
} // end of FEM_setMinDeltaCnt() function


void FEM_setParams(FEM_Handle handle,
                     const float_t timerFreq_Hz,
                     const uint32_t timerPeriod_cnts,
                     const float_t spFreq_Hz,
                     const float_t maxError_Hz);


static inline void FEM_setTimerPeriod(FEM_Handle handle,const uint32_t timerPeriod_cnts)
{
  FEM_Obj *obj = (FEM_Obj *)handle;

  obj->timerPeriod_cnts = timerPeriod_cnts;

  return;
} // end of FEM_setTimerPeriod() function


static inline void FEM_incrErrorCnt(FEM_Handle handle)
{
  uint32_t errorCnt = FEM_getErrorCnt(handle);

  errorCnt++;

  FEM_setErrorCnt(handle,errorCnt);

  return;
} // end of FEM_incrErrorCnt() function


static inline void FEM_run(FEM_Handle handle)
{
  uint32_t timerPeriod = FEM_getTimerPeriod(handle);
  uint32_t maxDeltaCnt = FEM_getMaxDeltaCnt(handle);
  uint32_t maxDeltaCntObserved = FEM_getMaxDeltaCntObserved(handle);
  uint32_t minDeltaCnt = FEM_getMinDeltaCnt(handle);
  uint32_t cnt_z0 = FEM_getCnt_z0(handle);
  uint32_t cnt_z1 = FEM_getCnt_z1(handle);

  uint32_t deltaCnt;


  // compute the actual frequency
  // handle wrap around of the timer count
  // NOTE: count down timer
  if(cnt_z0 > cnt_z1)
    {
      deltaCnt = cnt_z1 + timerPeriod - cnt_z0 + 1;
    }
  else
    {
      deltaCnt = cnt_z1 - cnt_z0 + 1;
    }


  // store the value 
  FEM_setDeltaCnt(handle,deltaCnt);


  // keep track of the maximum delta count observed
  if(deltaCnt > maxDeltaCntObserved)
    {
      // store the value 
      FEM_setMaxDeltaCntObserved(handle,deltaCnt);
    }


  // check for an error
  if((deltaCnt < minDeltaCnt) || (deltaCnt > maxDeltaCnt))
    {
      // set the flag
      FEM_setFlag_freqError(handle,true);

      // increment the counter
      FEM_incrErrorCnt(handle);
    }
  else
    {
      // set the flag
      FEM_setFlag_freqError(handle,false);
    }

  return;
} // end of FEM_run() function


static inline void FEM_updateCnts(FEM_Handle handle,const uint32_t cnt)
{
  uint32_t cnt_z0 = FEM_getCnt_z0(handle);

  FEM_setCnt_z1(handle,cnt_z0);
  FEM_setCnt_z0(handle,cnt);

  return;
} // end of FEM_updateCnts() function



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


#endif // end of _FEM_H_ definition