spintac_pos_move.h

Go to the documentation of this file.

#ifndef __SPINTAC_POS_MOVE_H__
#define __SPINTAC_POS_MOVE_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"

#ifndef __ST_AXIS_ENUM__
#define __ST_AXIS_ENUM__
typedef enum
{
  ST_AXIS0=0,   
  ST_AXIS1              
} ST_Axis_e;
#endif //__ST_AXIS_ENUM__

#ifndef __ST_MOVE_CURVE_TYPE_ENUM__
#define __ST_MOVE_CURVE_TYPE_ENUM__
typedef enum
{
  ST_MOVE_CUR_TRAP=0,   
  ST_MOVE_CUR_SCRV,             
  ST_MOVE_CUR_STCRV             
} ST_MoveCurveType_e;
#endif //__ST_MOVE_CURVE_TYPE_ENUM__

typedef enum
{
  ST_POS_MOVE_VEL_TYPE=0,       
  ST_POS_MOVE_POS_TYPE          
} ST_PosMoveProfileType_e;

#ifndef __ST_MOVE_STATUS_ENUM__
#define __ST_MOVE_STATUS_ENUM__
typedef enum
{
  ST_MOVE_IDLE=0,       
  ST_MOVE_INIT,         
  ST_MOVE_CONF,         
  ST_MOVE_BUSY,         
  ST_MOVE_HALT          
} ST_MoveStatus_e;
#endif //__ST_MOVE_STATUS_ENUM__

typedef struct {
  //System config parameters: Can be set only once at system startup
  ST_Axis_e Axis;                                       
  _iq24 T_sec;                                          
  _iq24 ROMax_mrev;                                     
  _iq24 mrev_TO_pu;                                     
  _iq24 HaltAccLim;                     
  _iq20 HaltJrkLim;                     
  // Config parameters that may be modified
  ST_PosMoveProfileType_e ProfileType;  
  ST_MoveCurveType_e CurveType;         
  _iq24 VelStart;                                       
  _iq24 PosStart_mrev;                          
} ST_PosMoveCfg_t;      // Structure for SpinTAC Move-Position configuration
                                

typedef struct {
  uint32_t ProTime_tick;    
  uint32_t ProTime_mtick;       
  _iq24 ActualVelLim;           
  _iq24 ActualAccLim;           
  _iq24 ActualDecLim;           
  _iq20 ActualJrkLim;           
} ST_PosMoveMsg_t;      // Structure for SpinTAC Move-Position information

typedef struct {
  /* Configuration Variables */
  ST_PosMoveCfg_t cfg;
  /* Input Variables */
  int32_t PosStepInt_mrev;      
  _iq24 PosStepFrac_mrev;       
  _iq24 VelLim;                         
  _iq24 AccLim;                         
  _iq24 DecLim;                         
  _iq20 JrkLim;                         
  _iq24 VelEnd;                         
  // Control bits
  bool ENB;                                 
  bool TST;                                 
  /* Output Variables */
  int32_t PosRollOver;          
  _iq24 PosRef_mrev;            
  _iq24 VelRef;                         
  _iq24 AccRef;                         
  _iq20 JrkRef;                         
  // Information structure
  ST_PosMoveMsg_t msg;
  // Information variables
  ST_MoveStatus_e STATUS;       
  uint16_t ERR_ID;                      
  /* Internal Variables */
  uint32_t s4[66];
} ST_PosMove_t; // Structure for SpinTAC Position Move

typedef struct _ST_POSMOVE_Handle_ *ST_POSMOVE_Handle; // SpinTAC Position Move Handle

static inline void STPOSMOVE_setAxis(ST_POSMOVE_Handle handle, ST_Axis_e axis) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.Axis = axis;
        }

        return;
} // end of STPOSMOVE_setAxis function

static inline void STPOSMOVE_setProfileType(ST_POSMOVE_Handle handle, ST_PosMoveProfileType_e profileType) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.ProfileType = profileType;
        }

        return;
} // end of STPOSMOVE_setProfileType function

static inline void STPOSMOVE_setCurveType(ST_POSMOVE_Handle handle, ST_MoveCurveType_e curveType) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->cfg.CurveType = curveType;

        return;
} // end of STPOSMOVE_setCurveType function

static inline void STPOSMOVE_setSampleTime_sec(ST_POSMOVE_Handle handle, _iq24 sampleTime) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

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

        return;
} // end of STPOSMOVE_setSampleTime_sec function

static inline void STPOSMOVE_setMRevMaximum_mrev(ST_POSMOVE_Handle handle, _iq24 mRevROMax) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.ROMax_mrev = mRevROMax;
        }

        return;
} // end of STPOSMOVE_setMRevMaximum_mrev function

static inline void STPOSMOVE_setUnitConversion(ST_POSMOVE_Handle handle, float_t baseFreq, uint16_t polePairs) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.mrev_TO_pu = _IQ24(((float_t)polePairs) / baseFreq);
        }

        return;
} // end of STPOSCONV_setUnitConversion function

static inline void STPOSMOVE_setHaltLimits(ST_POSMOVE_Handle handle, _iq24 haltAccLim, _iq20 haltJrkLim) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.HaltAccLim = haltAccLim;
                obj->cfg.HaltJrkLim = haltJrkLim;
        }

        return;
} // end of STPOSMOVE_setHaltLimits function

static inline void STPOSMOVE_setVelocityStart(ST_POSMOVE_Handle handle, _iq24 velStart) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.VelStart = velStart;
        }

        return;
} // end of STPOSMOVE_setVelocityStart function

static inline _iq24 STPOSMOVE_getVelocityStart(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->cfg.VelStart);
} // end of STPOSMOVE_getVelocityStart function

static inline void STPOSMOVE_setPositionStart_mrev(ST_POSMOVE_Handle handle, _iq24 posStart) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        if(obj->STATUS == ST_MOVE_IDLE) {
                obj->cfg.PosStart_mrev = posStart;
        }

        return;
} // end of STPOSMOVE_setPositionStart_mrev function

static inline _iq24 STPOSMOVE_getPositionStart_mrev(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->cfg.PosStart_mrev);
} // end of STPOSMOVE_getPositionStart_mrev function

static inline void STPOSMOVE_getProfileTime_tick(ST_POSMOVE_Handle handle, uint32_t *ProTime_tick, uint32_t *ProTime_mtick) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;
        *ProTime_tick = obj->msg.ProTime_tick;
        *ProTime_mtick = obj->msg.ProTime_mtick;
        return;
} // end of STPOSMOVE_getProfileTime_tick function

static inline _iq24 STPOSMOVE_getActualVelocity(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->msg.ActualVelLim);
} // end of STPOSMOVE_getActualVelocity function

static inline _iq24 STPOSMOVE_getActualAcceleration(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->msg.ActualAccLim);
} // end of STPOSMOVE_getActualAcceleration function

static inline _iq24 STPOSMOVE_getActualDeceleration(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->msg.ActualDecLim);
} // end of STPOSMOVE_getActualDeceleration function

static inline _iq20 STPOSMOVE_getActualJerk(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->msg.ActualJrkLim);
} // end of STPOSMOVE_getActualJerk function

static inline void STPOSMOVE_setPositionStep_mrev(ST_POSMOVE_Handle handle, int32_t posStepInt, _iq24 posStepFrac) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;
        obj->PosStepInt_mrev = posStepInt;
        obj->PosStepFrac_mrev = posStepFrac;

        return;
} // end of STPOSMOVE_getPositionStep_mrev function

static inline void STPOSMOVE_getPositionStep_mrev(ST_POSMOVE_Handle handle, int32_t *posStepInt, _iq24 *posStepFrac) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;
        *posStepInt = obj->PosStepInt_mrev;
        *posStepFrac = obj->PosStepFrac_mrev;

        return;
} // end of STPOSMOVE_getPositionStep_mrev function

static inline void STPOSMOVE_setVelocityLimit(ST_POSMOVE_Handle handle, _iq24 velLim) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->VelLim = velLim;

        return;
} // end of STPOSMOVE_setVelocityLimit function

static inline void STPOSMOVE_setAccelerationLimit(ST_POSMOVE_Handle handle, _iq24 accLim) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->AccLim = accLim;

        return;
} // end of STPOSMOVE_setAccelerationLimit function

static inline void STPOSMOVE_setDecelerationLimit(ST_POSMOVE_Handle handle, _iq24 decLim) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->DecLim = decLim;

        return;
} // end of STPOSMOVE_setDecelerationLimit function

static inline void STPOSMOVE_setJerkLimit(ST_POSMOVE_Handle handle, _iq20 jrkLim) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->JrkLim = jrkLim;

        return;
} // end of STPOSMOVE_setJerkLimit function

static inline void STPOSMOVE_setVelocityEnd(ST_POSMOVE_Handle handle, _iq24 velEnd) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->VelEnd = velEnd;

        return;
} // end of STPOSMOVE_setVelocityEnd function

static inline _iq24 STPOSMOVE_getVelocityEnd(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->VelEnd);
} // end of STPOSMOVE_getVelocityEnd function

static inline void STPOSMOVE_setPositionRollOver(ST_POSMOVE_Handle handle, int32_t posRollOver) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->PosRollOver = posRollOver;

        return;
} // end of STPOSMOVE_setPositionRollOver function

static inline int32_t STPOSMOVE_getPositionRollOver(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->PosRollOver);
} // end of STPOSMOVE_getPositionReference function

static inline _iq24 STPOSMOVE_getPositionReference_mrev(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->PosRef_mrev);
} // end of STPOSMOVE_getPositionReference_mrev function

static inline _iq24 STPOSMOVE_getVelocityReference(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->VelRef);
} // end of STPOSMOVE_getVelocityReference function

static inline _iq24 STPOSMOVE_getAccelerationReference(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->AccRef);
} // end of STPOSMOVE_getAccelerationReference function

static inline _iq20 STPOSMOVE_getJerkReference(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return(obj->JrkRef);
} // end of STPOSMOVE_getJerkReference function

static inline void STPOSMOVE_setEnable(ST_POSMOVE_Handle handle, bool enb) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->ENB = enb;

        return;
} // end of STPOSMOVE_setEnable function

static inline bool STPOSMOVE_getEnable(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

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

static inline void STPOSMOVE_setTest(ST_POSMOVE_Handle handle, bool tst) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        obj->TST = tst;

        return;
} // end of STPOSMOVE_setTest function

static inline bool STPOSMOVE_getTest(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

        return (obj->TST);
} // end of STPOSMOVE_getTest function

static inline ST_MoveStatus_e STPOSMOVE_getStatus(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

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

static inline uint16_t STPOSMOVE_getErrorID(ST_POSMOVE_Handle handle) {
        ST_PosMove_t *obj = (ST_PosMove_t *)handle;

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

ST_POSMOVE_Handle STPOSMOVE_init(void *pMemory, const size_t numBytes);

void STPOSMOVE_run(ST_POSMOVE_Handle handle);

#endif //__SPINTAC_POS_MOVE_H__