float/cal.h

Go to the documentation of this file.

#ifndef _CAL_H_
#define _CAL_H_



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


// drivers 


// modules
#include "sw/modules/types/src/types.h"
#include "sw/modules/cal/src/cal_states.h"
#include "sw/modules/hal/src/float/hal_data.h"
#include "sw/modules/math/src/float/math.h"
#include "sw/modules/offset/src/float/offset.h"
#include "sw/modules/user/src/float/userParams.h"


// solutions
#include "user.h"






#ifdef __cplusplus
extern "C" {
#endif


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


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


typedef struct _CAL_Obj_
{
  CAL_State_e      state;                                     

  int_least32_t    counter_state;                             
  int_least32_t    waitTimes[CAL_numStates];                  

  OFFSET_Handle    offsetHandle_I[USER_NUM_CURRENT_SENSORS];  
  OFFSET_Obj       offset_I[USER_NUM_CURRENT_SENSORS];        

  OFFSET_Handle    offsetHandle_V[USER_NUM_VOLTAGE_SENSORS];  
  OFFSET_Obj       offset_V[USER_NUM_VOLTAGE_SENSORS];        

  bool             flag_enable;                               
  bool             flag_enableAdcOffset;                      
} CAL_Obj;


typedef struct _CAL_Obj_  *CAL_Handle;


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


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

static inline void CAL_disable(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->flag_enable = false;

  return;
} // end of CAL_disable() function


static inline void CAL_enable(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->flag_enable = true;

  return;
} // end of CAL_enable() function


static inline int_least32_t CAL_getCount_state(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

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


static inline bool CAL_getFlag_enable(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

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


static inline bool CAL_getFlag_enableAdcOffset(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  return(obj->flag_enableAdcOffset);
} // end of CAL_getFlag_enableAdcOffset() function


static inline OFFSET_Handle *CAL_getOffsetHandleAddr_I(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  return(&(obj->offsetHandle_I[0]));
} // end of CAL_getOffsetHandleAddr_I() function


static inline OFFSET_Handle *CAL_getOffsetHandleAddr_V(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  return(&(obj->offsetHandle_V[0]));
} // end of CAL_getOffsetHandleAddr_V() function


static inline float_t CAL_getOffsetValue_I(CAL_Handle handle,
                                           const uint_least8_t sensorNumber)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  float_t offset = OFFSET_getOffset(obj->offsetHandle_I[sensorNumber]);

  return(offset);
} // end of CAL_getOffsetValue_I() function


static inline float_t CAL_getOffsetValue_V(CAL_Handle handle,
                                           const uint_least8_t sensorNumber)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  float_t offset = OFFSET_getOffset(obj->offsetHandle_V[sensorNumber]);

  return(offset);
} // end of CAL_getOffsetValue_V() function


static inline CAL_State_e CAL_getState(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

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


static inline int_least32_t CAL_getWaitTime(CAL_Handle handle,const CAL_State_e state)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

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


static inline void CAL_incrCounter_state(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_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 CAL_incrCounter_state() function


extern CAL_Handle CAL_init(void *pMemory,const size_t numBytes);


static inline bool CAL_isEnabled(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

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


static inline bool CAL_isError(CAL_Handle handle)
{
  CAL_State_e calState = CAL_getState(handle);
  bool state = false;


  // check for controller errors
  if(calState == CAL_State_Error)
    {
      state = true;
    }

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


static inline bool CAL_isIdle(CAL_Handle handle)
{
  CAL_State_e state = CAL_getState(handle);
  bool result = false;

  if(state == CAL_State_Idle)
    {
      result = true;
    }
  
  return(result);
} // end of CAL_isIdle() function


static inline bool CAL_isNotIdle(CAL_Handle handle)
{
  CAL_State_e state = CAL_getState(handle);
  bool result = true;

  if(state == CAL_State_Idle)
    {
      result = false;
    }
  
  return(result);
} // end of CAL_isNotIdle() function


extern void CAL_reset(CAL_Handle handle);


static inline void CAL_resetCounter_state(CAL_Handle handle)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->counter_state = 0;

  return;
} // end of CAL_resetCounter_state() function


static inline void CAL_setCount_state(CAL_Handle handle,const int_least32_t count)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->counter_state = count;

  return;
} // end of CAL_setCount_state() function


static inline void CAL_setFlag_enable(CAL_Handle handle,const bool value)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->flag_enable = value;

  return;
} // end of CAL_setFlag_enable() function


static inline void CAL_setFlag_enableAdcOffset(CAL_Handle handle,const bool value)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->flag_enableAdcOffset = value;

  return;
} // end of CAL_setFlag_enableAdcOffset() function


extern void CAL_setParams(CAL_Handle handle,
                          const USER_Params *pUserParams);


static inline void CAL_setState(CAL_Handle handle,const CAL_State_e state)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->state = state;

  return;
} // end of CAL_setState() function


static inline void CAL_setWaitTime(CAL_Handle handle,const CAL_State_e state,const int_least32_t waitTime)
{
  CAL_Obj *obj = (CAL_Obj *)handle;

  obj->waitTimes[state] = waitTime;

  return;
} // end of CAL_setWaitTime() function


extern void CAL_setWaitTimes(CAL_Handle handle,const int_least32_t *pWaitTimes);


static inline void CAL_setup(CAL_Handle handle)
{

  return;
} // end of CAL_setup() function


static inline void CAL_run(CAL_Handle handle,const HAL_AdcData_t *pAdcData)
{
  CAL_State_e state = CAL_getState(handle);


  // compute the Adc offset
  if(state == CAL_State_AdcOffset)
    {
      CAL_Obj *obj = (CAL_Obj *)handle;
      uint_least8_t cnt;

      // estimate the current offsets
      for(cnt=0;cnt<USER_NUM_CURRENT_SENSORS;cnt++)
        {
          OFFSET_run(obj->offsetHandle_I[cnt],pAdcData->I_A.value[cnt]);
        }


      // estimate the voltage offsets
      for(cnt=0;cnt<USER_NUM_VOLTAGE_SENSORS;cnt++)
        {
          OFFSET_run(obj->offsetHandle_V[cnt],pAdcData->V_V.value[cnt]);
        }
    }


  // increment the state counter
  CAL_incrCounter_state(handle);

  return;
} // end of CAL_run() function


extern bool CAL_updateState(CAL_Handle handle);


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


#endif // end of _CAL_H_ definition