spintac_vel_id.h

Go to the documentation of this file.

#ifndef __SPINTAC_VEL_ID_H__
#define __SPINTAC_VEL_ID_H__
/* --COPYRIGHT--,BSD
 * Copyright (c) 2012, LineStream Technologies Incorporated
 * 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 names of Texas Instruments Incorporated, LineStream
 *    Technologies 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--*/




#include "spintac_version.h"

typedef enum
{
  ST_VEL_ID_IDLE=0,     
  ST_VEL_ID_INIT,       
  ST_VEL_ID_BUSY        
} ST_VelIdStatus_e;

typedef struct {
  // Configuration parameters: Can be set only once at system startup
  _iq24  T_sec;                 
  int16_t LpfTime_tick; 
  _iq24  TimeOut_sec;   

  // Config parameters that may be modified
  _iq24  GoalSpeed;             
  _iq24  OutMax;            
  _iq24  RampTime_sec;  
  bool Sensorless;      
} ST_VelIdCfg_t;                // Structure for SpinTAC Identify configuration


typedef struct {
  // Configuration structure
  ST_VelIdCfg_t cfg;            
  /* Input Variables */
  _iq24  VelFdb;                        
  // Control bits
  bool ENB;                                 
  /* Output Variables */
  _iq24  Out;                           
  // Estimation Result
  _iq24  InertiaEst;            
  _iq24  FrictionEst;           
  // Information variables
  ST_VelIdStatus_e STATUS;      
  uint16_t ERR_ID;                      
  /* Internal variables */
  uint32_t s0[9];
} ST_VelId_t;   // Structure for SpinTAC Identify

typedef struct _ST_VELID_Handle_ *ST_VELID_Handle; // SpinTAC Velocity Identify Handle

static inline void STVELID_setSampleTime_sec(ST_VELID_Handle handle, _iq24 sampleTime) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        if(obj->STATUS == ST_VEL_ID_IDLE) {
                obj->cfg.T_sec = sampleTime;
        }

        return;
} // end of STVELID_setSampleTime_sec function

static inline void STVELID_setOutputMaximum(ST_VELID_Handle handle, _iq24 outMax) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        if(obj->STATUS == ST_VEL_ID_IDLE) {
                obj->cfg.OutMax = outMax;
        }

        return;
} // end of STVELID_setOutputMaximum function

static inline void STVELID_setGoalSpeed(ST_VELID_Handle handle, _iq24 goalSpeed) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        obj->cfg.GoalSpeed = goalSpeed;

        return;
} // end of STVELID_setGoalSpeed function

static inline _iq24 STVELID_getGoalSpeed(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return(obj->cfg.GoalSpeed);
} // end of STVELID_getGoalSpeed function

static inline void STVELID_setLowPassFilterTime_tick(ST_VELID_Handle handle, int16_t lpfTime) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        if(obj->STATUS == ST_VEL_ID_IDLE) {
                obj->cfg.LpfTime_tick = lpfTime;
        }

        return;
} // end of STVELID_setLowPassFilterTime_tick function

static inline void STVELID_setTimeOut_sec(ST_VELID_Handle handle, _iq24 timeOut) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        if(obj->STATUS == ST_VEL_ID_IDLE) {
                obj->cfg.TimeOut_sec = timeOut;
        }

        return;
} // end of STVELID_setTimeOut_sec function

static inline void STVELID_setTorqueRampTime_sec(ST_VELID_Handle handle, _iq24 rampTime) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        if(obj->STATUS == ST_VEL_ID_IDLE) {
                obj->cfg.RampTime_sec = rampTime;
        }

        return;
} // end of STVELID_setTorqueRampTime_sec function

static inline _iq24 STVELID_getTorqueRampTime_sec(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return(obj->cfg.RampTime_sec);
} // end of STVELID_getTorqueRampTime_sec function

static inline void STVELID_setSensorlessFeedback(ST_VELID_Handle handle, bool sensorless) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        if(obj->STATUS == ST_VEL_ID_IDLE) {
                obj->cfg.Sensorless = sensorless;
        }

        return;
} // end of STVELID_setTorqueRampTime_sec function

static inline void STVELID_setVelocityFeedback(ST_VELID_Handle handle, _iq24 velFdb) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        obj->VelFdb = velFdb;

        return;
} // end of STVELID_setVelocityFeedback function

static inline _iq24 STVELID_getTorqueReference(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return (obj->Out);
} // end of STVELID_getTorqueReference function

static inline void STVELID_setTorqueReference(ST_VELID_Handle handle, _iq24 out) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        obj->Out = out;

        return;
} // end of STVELID_setTorqueReference function

static inline _iq24 STVELID_getInertiaEstimate(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return (obj->InertiaEst);
} // end of STVELID_getInertiaEstimate function

static inline _iq24 STVELID_getFrictionEstimate(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return (obj->FrictionEst);
} // end of STVELID_getFrictionEstimate function

static inline void STVELID_setEnable(ST_VELID_Handle handle, bool enb) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        obj->ENB = enb;

        return;
} // end of STVELID_setEnable function

static inline bool STVELID_getEnable(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return (obj->ENB);
} // end of STVELID_getEnable function

static inline ST_VelIdStatus_e STVELID_getStatus(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return (obj->STATUS);
} // end of STVELID_getStatus function

static inline uint16_t STVELID_getErrorID(ST_VELID_Handle handle) {
        ST_VelId_t *obj = (ST_VelId_t *)handle;

        return (obj->ERR_ID);
} // end of STVELID_getErrorID function

ST_VELID_Handle STVELID_init(void *pMemory, const size_t numBytes);

void STVELID_run(ST_VELID_Handle handle);

#endif //__SPINTAC_VEL_ID_H__