spintac_vel_plan.h

Go to the documentation of this file.

#ifndef __SPINTAC_VEL_PLAN_H__
#define __SPINTAC_VEL_PLAN_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"

#define ST_VEL_PLAN_ACT_DWORDS          (5)
#define ST_VEL_PLAN_COND_DWORDS         (3)
#define ST_VEL_PLAN_VAR_DWORDS          (2)
#define ST_VEL_PLAN_TRAN_DWORDS         (5)
#define ST_VEL_PLAN_STATE_DWORDS        (6)


#ifndef __ST_PLAN_ENUM__
#define __ST_PLAN_ENUM__
typedef enum {
  ST_PLAN_IDLE=0, 
  ST_PLAN_INIT,   
  ST_PLAN_BUSY,   
  ST_PLAN_HALT,   
  ST_PLAN_WAIT    
} ST_PlanStatus_e;

typedef enum {
  ST_COND_NC=0, 
  ST_COND_FC,   
  ST_COND_AND,  
  ST_COND_OR    
} ST_PlanCond_e;

typedef enum {
  ST_COMP_NA=0, 
  ST_COMP_EQ,   
  ST_COMP_NEQ,  
  ST_COMP_GT,   
  ST_COMP_EGT,  
  ST_COMP_LW,   
  ST_COMP_ELW,  
  ST_COMP_In,   
  ST_COMP_EIn,  
  ST_COMP_InE,  
  ST_COMP_EInE, 
  ST_COMP_Out,  
  ST_COMP_EOut, 
  ST_COMP_OutE, 
  ST_COMP_EOutE 
} ST_PlanComp_e;

typedef enum {
  ST_ACT_EQ=0, 
  ST_ACT_ADD   
} ST_PlanActOptn_e;

typedef enum {
  ST_ACT_ENTR=0, 
  ST_ACT_EXIT    
} ST_PlanActTrgr_e;

typedef enum {
  ST_FSM_STATE_STAY=0,  
  ST_FSM_STATE_COND,    
  ST_FSM_STATE_TRAN             
} ST_PlanFsmState_e;

typedef enum {
  ST_VAR_INOUT=0,       
  ST_VAR_IN,            
  ST_VAR_OUT            
} ST_PlanVar_e;
#endif //__ST_PLAN_ENUM__

#ifndef __ST_PLAN_ERROR__
#define __ST_PLAN_ERROR__
typedef struct {
        uint16_t ERR_idx;       
        uint16_t ERR_code;      
} ST_PlanError_t;       // Structure for SpinTAC Plan Error
#endif //__ST_PLAN_ERROR__

typedef struct {
  /* Input variables */
  // Control bits
  bool ENB;                   
  bool RES;                   
  /* Output variables */
  _iq24 VelEnd;               
  _iq24 AccLim;               
  _iq20 JrkLim;               
  // Information variables
  ST_PlanStatus_e STATUS;     
  uint16_t CurState;          
  uint16_t CurTran;           
  ST_PlanFsmState_e FsmState; 
  int32_t Timer_tick;         
  uint16_t ERR_ID;            
  ST_PlanError_t CfgError;    
  /* Internal variables */
  uint32_t s0[26];
} ST_VelPlan_t;                 // Structure for SpinTAC Velocity Plan

typedef struct _ST_VELPLAN_Handle_ *ST_VELPLAN_Handle; // SpinTAC Velocity Plan Handle

static inline _iq24 STVELPLAN_getVelocitySetpoint(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

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

static inline _iq24 STVELPLAN_getAccelerationLimit(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return(obj->AccLim);
} // end of STVELPLAN_getAccelerationLimit function

static inline _iq20 STVELPLAN_getJerkLimit(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return(obj->JrkLim);
} // end of STVELPLAN_getJerkLimit function

static inline void STVELPLAN_setEnable(ST_VELPLAN_Handle handle, bool enb) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        obj->ENB = enb;

        return;
} // end of STVELPLAN_setEnable function

static inline bool STVELPLAN_getEnable(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

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

static inline void STVELPLAN_setReset(ST_VELPLAN_Handle handle, bool res) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        obj->RES = res;

        return;
} // end of STVELPLAN_setReset function

static inline bool STVELPLAN_getReset(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return (obj->RES);
} // end of STVELPLAN_getReset function

static inline ST_PlanStatus_e STVELPLAN_getStatus(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

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


static inline uint16_t STVELPLAN_getCurrentState(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return(obj->CurState);
} // end of STVELPLAN_getCurrentState function

static inline uint16_t STVELPLAN_getCurrentTransition(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return(obj->CurTran);
} // end of STVELPLAN_getCurrentTransition function

static inline ST_PlanFsmState_e STVELPLAN_getFsmState(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return(obj->FsmState);
} // end of STVELPLAN_getFsmState function

static inline int32_t STVELPLAN_getCurrentTimerValue_tick(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        return(obj->Timer_tick);
} // end of STVELPLAN_getCurrentTimerValue_tick function

static inline uint16_t STVELPLAN_getCfgError(ST_VELPLAN_Handle handle, uint16_t *ERR_idx, uint16_t *ERR_code) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

        *ERR_idx = obj->CfgError.ERR_idx;
        *ERR_code = obj->CfgError.ERR_code;

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

static inline uint16_t STVELPLAN_getErrorID(ST_VELPLAN_Handle handle) {
        ST_VelPlan_t *obj = (ST_VelPlan_t *)handle;

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

void STVELPLAN_getCfgStateNum(ST_VELPLAN_Handle handle, uint16_t *StateNum);

void STVELPLAN_getCfgVarNum(ST_VELPLAN_Handle handle, uint16_t *VarNum);

void STVELPLAN_getCfgCondNum(ST_VELPLAN_Handle handle, uint16_t *CondNum);

void STVELPLAN_getCfgTranNum(ST_VELPLAN_Handle handle, uint16_t *TranNum);

void STVELPLAN_getCfgActNum(ST_VELPLAN_Handle handle, uint16_t *ActNum);

void STVELPLAN_addCfgCond(ST_VELPLAN_Handle handle, uint16_t VarIdx, ST_PlanComp_e Comp, _iq24 Value1, _iq24 Value2);

void STVELPLAN_delCfgCond(ST_VELPLAN_Handle handle, uint16_t CondIdx);

void STVELPLAN_setCfgCond(ST_VELPLAN_Handle handle, uint16_t CondIdx, uint16_t VarIdx, ST_PlanComp_e Comp, _iq24 Value1, _iq24 Value2);

void STVELPLAN_getCfgCond(ST_VELPLAN_Handle handle, uint16_t CondIdx, uint16_t *VarIdx, ST_PlanComp_e *Comp, _iq24 *Value1, _iq24 *Value2);

void STVELPLAN_addCfgVarCond(ST_VELPLAN_Handle handle, uint16_t VarIdx1, uint16_t VarIdx2, ST_PlanComp_e Comp);

void STVELPLAN_delCfgVarCond(ST_VELPLAN_Handle handle, uint16_t CondIdx);

void STVELPLAN_setCfgVarCond(ST_VELPLAN_Handle handle, uint16_t CondIdx, uint16_t VarIdx1, uint16_t VarIdx2, ST_PlanComp_e Comp);

void STVELPLAN_getCfgVarCond(ST_VELPLAN_Handle handle, uint16_t CondIdx, uint16_t *VarIdx1, uint16_t *VarIdx2, ST_PlanComp_e *Comp);

void STVELPLAN_addCfgTran(ST_VELPLAN_Handle handle, uint16_t FromState, uint16_t ToState, ST_PlanCond_e AndOr, uint16_t CondIdx1, uint16_t CondIdx2, _iq24 AccLim, _iq20 JrkLim);

void STVELPLAN_delCfgTran(ST_VELPLAN_Handle handle, uint16_t TranIdx);

void STVELPLAN_setCfgTran(ST_VELPLAN_Handle handle, uint16_t TranIdx, uint16_t FromState, uint16_t ToState, ST_PlanCond_e AndOr, uint16_t CondIdx1, uint16_t CondIdx2, _iq24 AccLim, _iq20 JrkLim);

void STVELPLAN_getCfgTran(ST_VELPLAN_Handle handle, uint16_t TranIdx, uint16_t *FromState, uint16_t *ToState, ST_PlanCond_e *AndOr, uint16_t *CondIdx1, uint16_t *CondIdx2, _iq24 *AccLim, _iq20 *JrkLim);

void STVELPLAN_addCfgAct(ST_VELPLAN_Handle handle, uint16_t State, ST_PlanCond_e AndOr, uint16_t CondIdx1, uint16_t CondIdx2, uint16_t VarIdx, ST_PlanActOptn_e Opt, _iq24 Value, ST_PlanActTrgr_e EnterExit);

void STVELPLAN_delCfgAct(ST_VELPLAN_Handle handle, uint16_t ActIdx);

void STVELPLAN_setCfgAct(ST_VELPLAN_Handle handle, uint16_t ActIdx, uint16_t State, ST_PlanCond_e AndOr, uint16_t CondIdx1, uint16_t CondIdx2, uint16_t VarIdx, ST_PlanActOptn_e Opt, _iq24 Value, ST_PlanActTrgr_e EnterExit);

void STVELPLAN_getCfgAct(ST_VELPLAN_Handle handle, uint16_t ActIdx, uint16_t *State, ST_PlanCond_e *AndOr, uint16_t *CondIdx1, uint16_t *CondIdx2, uint16_t *VarIdx, ST_PlanActOptn_e *Opt, _iq24 *Value, ST_PlanActTrgr_e *EnterExit);

void STVELPLAN_addCfgVar(ST_VELPLAN_Handle handle, ST_PlanVar_e Type, _iq24 Value);

void STVELPLAN_delCfgVar(ST_VELPLAN_Handle handle, uint16_t VarIdx);

void STVELPLAN_setCfgVar(ST_VELPLAN_Handle handle, uint16_t VarIdx, ST_PlanVar_e Type, _iq24 Value);

void STVELPLAN_getCfgVar(ST_VELPLAN_Handle handle, uint16_t VarIdx, ST_PlanVar_e *Type, _iq24 *Value);

void STVELPLAN_setVar(ST_VELPLAN_Handle handle, uint16_t VarIdx, _iq24 Value);

void STVELPLAN_getVar(ST_VELPLAN_Handle handle, uint16_t VarIdx, _iq24 *Value);

void STVELPLAN_setUnitProfDone(ST_VELPLAN_Handle handle, bool ProDON);

void STVELPLAN_setCfg(ST_VELPLAN_Handle handle, _iq24 T_sec, bool LoopENB);

void STVELPLAN_getCfg(ST_VELPLAN_Handle handle, _iq24 *T_sec, bool *LoopENB);

void STVELPLAN_setCfgHaltState(ST_VELPLAN_Handle handle, _iq24 VelEnd, _iq24 AccLim, _iq20 JrkLim, int32_t Timer_tick);

void STVELPLAN_getCfgHaltState(ST_VELPLAN_Handle handle, _iq24 *VelEnd, _iq24 *AccLim, _iq20 *JrkLim, int32_t *Timer_tick);

void STVELPLAN_addCfgState(ST_VELPLAN_Handle handle, _iq24 VelEnd, int32_t Timer_tick);

void STVELPLAN_delCfgState(ST_VELPLAN_Handle handle, uint16_t StateIdx);

void STVELPLAN_setCfgState(ST_VELPLAN_Handle handle, uint16_t StateIdx, _iq24 VelEnd, int32_t Timer_tick);

void STVELPLAN_getCfgState(ST_VELPLAN_Handle handle, uint16_t StateIdx, _iq24 *VelEnd, int32_t *Timer_tick);

void STVELPLAN_reset(ST_VELPLAN_Handle handle);

ST_VELPLAN_Handle STVELPLAN_init(void *pMemory, const size_t numBytes);

void STVELPLAN_run(ST_VELPLAN_Handle handle);

void STVELPLAN_runTick(ST_VELPLAN_Handle handle);

void STVELPLAN_setCfgArray(ST_VELPLAN_Handle handle, uint32_t *cfgArray, const size_t numBytes, uint16_t MaxActNum,uint16_t MaxCondNum, uint16_t MaxVarNum, uint16_t MaxTranNum, uint16_t MaxStateNum);

#endif /*__SPINTAC_VEL_PLAN_H__*/