INOS
cinosbaseaxis.h
Go to the documentation of this file.
1 //******************************************************************************
27 //******************************************************************************
28 
29 #ifndef INC_CINOSBASEAXIS_H
30 #define INC_CINOSBASEAXIS_H
31 //
32 //------------------------------------------------------------------------------
33 // defines
34 //------------------------------------------------------------------------------
35 //
36 #define DF_INOS_BASE_AXIS_DBT "INOS-BASE-AXIS" // db table name
37 //
38 #if defined(INOS_64)
39 #define DF_INOS_MAX_AXIS 512 // max. number of allowed axis
40 #else
41 #define DF_INOS_MAX_AXIS 256 // max. number of allowed axis
42 #endif
43 //
44 // --- axis states -------------------------------------------------------------
45 //
46 #define DF_INOS_AXIS_STATE_DISABLED -1 // static state 'disabled'
47 #define DF_INOS_AXIS_STATE_UNDEFINED 0 // static state 'undefined'
48 #define DF_INOS_AXIS_STATE_OFF 0 // static state 'off', same as 'undefined'
49 #define DF_INOS_AXIS_STATE_ACTIVE 1 // static state 'active'
50 #define DF_INOS_AXIS_STATE_READY 2 // static state 'ready'
51 #define DF_INOS_AXIS_STATE_PEACE 2 // static state 'ready'
52 #define DF_INOS_AXIS_STATE_PULL 3 // static state 'pull'
53 #define DF_INOS_AXIS_STATE_BREAK 4 // static state 'break'
54 #define DF_INOS_AXIS_STATE_COUPLED 5 // static state 'coupled'
55 #define DF_INOS_AXIS_STATE_FORCE 6 // static state 'force'
56 #define DF_INOS_AXIS_STATE_ACTIVATING 8 // dynamic state 'activating'
57 #define DF_INOS_AXIS_STATE_INACTIVATING 9 // dynamic state 'inactivating'
58 #define DF_INOS_AXIS_STATE_SYNCING 10 // dynamic state 'syncing'
59 #define DF_INOS_AXIS_STATE_MOVING 11 // dynamic state 'moving'
60 #define DF_INOS_AXIS_STATE_ENDLESS 12 // dynamic state 'endless'
61 #define DF_INOS_AXIS_STATE_TOGGLE 13 // dynamic state 'toggle'
62 #define DF_INOS_AXIS_STATE_STOPPING 14 // dynamic state 'stopping'
63 #define DF_INOS_AXIS_STATE_BREAKING 15 // dynamic state 'breaking'
64 #define DF_INOS_AXIS_STATE_EMSTOPPING 16 // dynamic state 'emergency stopping'
65 #define DF_INOS_AXIS_STATE_MOVINGEX 17 // dynamic state 'moving ex'
66 #define DF_INOS_AXIS_STATE_CURSOR 18 // dynamic state 'cursor'
67 #define DF_INOS_AXIS_STATE_TRACK 19 // dynamic state 'track'
68 #define DF_INOS_AXIS_STATE_MOVINGAPP 20 // dynamic state 'movingapp'
69 #define DF_INOS_AXIS_STATE_MOVINGDEP 21 // dynamic state 'movingapp'
70 #define DF_INOS_AXIS_STATE_RELAXING 22 // dynamic state 'relaxing'
71 #define DF_INOS_AXIS_STATE_UMOVE 23 // dynamic state 'micromove' => see also DF_INOS_CONTROL_SUBSTATE_ACTIVE_UMOVE
72 #define DF_INOS_AXIS_STATE_SEARCHING 24 // dynamic state 'searching touch down'
73 #define DF_INOS_AXIS_STATE_DEPARTING 25 // dynamic state 'departing from touch down'
74 #define DF_INOS_AXIS_STATES 27 // number of states
75 //
76 // --- axis substates ----------------------------------------------------------
77 //
78 #define DF_INOS_AXIS_SUBSTATE_TRACK_FOLLOW 0 // track mode 'follow'
79 #define DF_INOS_AXIS_SUBSTATE_TRACK_KEEP 1 // track mode 'keep'
80 //
81 // --- axis commands -----------------------------------------------------------
82 //
83 #define DF_INOS_AXIS_CMD_ACTIVATE 0x00000001 // command 'Activate'
84 #define DF_INOS_AXIS_CMD_INACTIVATE 0x00000002 // command 'InActivate'
85 #define DF_INOS_AXIS_CMD_SYNC 0x00000004 // command 'Sync'
86 #define DF_INOS_AXIS_CMD_MOVE 0x00000008 // command 'Move'
87 #define DF_INOS_AXIS_CMD_ENDLESS 0x00000010 // command 'Endless'
88 #define DF_INOS_AXIS_CMD_STOP 0x00000020 // command 'Stop'
89 #define DF_INOS_AXIS_CMD_BREAK 0x00000040 // command 'Break'
90 #define DF_INOS_AXIS_CMD_CONTINUE 0x00000080 // command 'Continue'
91 #define DF_INOS_AXIS_CMD_EMSTOP 0x00000100 // command 'EmergencyStop'
92 #define DF_INOS_AXIS_CMD_UPDATE 0x00000200 // command 'Update'
93 #define DF_INOS_AXIS_CMD_TOGGLE 0x00000400 // command 'Toggle'
94 #define DF_INOS_AXIS_CMD_MOVEEX 0x00002000 // command 'MoveEx'
95 #define DF_INOS_AXIS_CMD_HANDLE_CACHE 0x00004000 // commands 'Enable,Disable,FlushCache'
96 #define DF_INOS_AXIS_CMD_CURSOR 0x00008000 // command 'Cursor'
97 #define DF_INOS_AXIS_CMD_TRACK 0x00010000 // command 'Track'
98 #define DF_INOS_AXIS_CMD_MOVESEG 0x00020000 // command 'Seg...'
99 #define DF_INOS_AXIS_CMD_COUPLING 0x00040000 // command 'couple'
100 #define DF_INOS_AXIS_CMD_PULL 0x00080000 // command 'pull'
101 #define DF_INOS_AXIS_CMD_MOVEAPP 0x00100000 // command 'MoveApp'
102 #define DF_INOS_AXIS_CMD_MOVEDEP 0x00200000 // command 'MoveDep'
103 #define DF_INOS_AXIS_CMD_ENABLE 0x00400000 // command 'Enable'
104 #define DF_INOS_AXIS_CMD_DISABLE 0x00800000 // command 'Disable'
105 #define DF_INOS_AXIS_CMD_COMMUTATE 0x01000000 // command 'Commutate'
106 #define DF_INOS_AXIS_CMD_MOVETIME 0x02000000 // command 'MoveTime'
107 #define DF_INOS_AXIS_CMD_RELAX 0x04000000 // command 'Relax'
108 //
109 // --- axis errors -------------------------------------------------------------
110 //
111 #define ER_INOS_AXIS_REJECTED 0x00000001 // command rejected
112 #define ER_INOS_AXIS_FAILED 0x00000002 // command failed
113 #define ER_INOS_AXIS_POS_WINDOW 0x00000004 // positioning window failed
114 #define ER_INOS_AXIS_CPD_ERROR 0x00000008 // coupled axis on error
115 #define ER_INOS_AXIS_CPD_DELTA 0x00000010 // coupling max delta reached
116 #define ER_INOS_AXIS_CPD_CORR 0x00000020 // coupling max correction reached
117 #define ER_INOS_AXIS_COM_FAILED 0x00000040 // communication to foreign controller failed
118 #define ER_INOS_AXIS_RAMP_LIMIT 0x00000080 // ramp limits exceeded
119 #define ER_INOS_AXIS_REJECTED_SOS 0x00000100// command SOS (safe operating stop) rejected
120 #define ER_INOS_AXIS_PULL_UNDERRUN 0x00000200// pull underrun detected
121 #define ER_INOS_AXIS_SLS_VIOLATION 0x00000400// emergency stop due to upcoming SLS violation
122 #define ER_INOS_AXIS_SOS_VIOLATION 0x00000800// emergency stop due to upcoming SOS violation
123 #define ER_INOS_AXIS_CORE_MISMATCH 0x00001000// core mismatch
124 #define ER_INOS_AXIS_FORCE_CONTROL 0x00002000 // force control error pending
125 #define ER_INOS_AXIS_CONTROL 0x00004000 // control error pending
126 #define ER_INOS_AXIS_RAMP 0x00008000 // ramp error pending
127 #define ER_INOS_AXIS_HOOK 0x00010000 // registering hook failed
128 //
129 // --- axis warnings -----------------------------------------------------------
130 //
131 #define WR_INOS_AXIS_RAMP 0x00008000 // ramp warning pending
132 #define WR_INOS_AXIS_CONTROL 0x00004000 // control warning pending
133 #define WR_INOS_AXIS_IGNORED 0x00000001 // command ignored
134 #define WR_INOS_AXIS_CPD_CORR_IGNORED 0x00000002 // coupling correction ignored
135 #define WR_INOS_AXIS_COUPLED 0x00000008 // coupled axis has warning
136 #define WR_INOS_AXIS_EME_STOPPED 0x00000010 // the axis has been emergency stopped
137 //
138 // --- axis flags --------------------------------------------------------------
139 //
140 #define DF_INOS_AXIS_FLAG_ZERO 0x00000001 // zero position after move
141 #define DF_INOS_AXIS_FLAG_NORM 0x00000002 // norm position after move
142 #define DF_INOS_AXIS_FLAG_INCR 0x00000004 // incremental moves
143 #define DF_INOS_AXIS_FLAG_SYNC 0x00000008 // live sync position
144 #define DF_INOS_AXIS_FLAG_EDONE 0x00000010 // early done
145 #define DF_INOS_AXIS_FLAG_AACC 0x00000020 // auto accept errors on activate
146 #define DF_INOS_AXIS_FLAG_CURL 0x00000040 // current limitation
147 #define DF_INOS_AXIS_FLAG_LSNCD 0x00000080 // limits only checked if synched
148 #define DF_INOS_AXIS_FLAG_DISMP 0x00000100 // mapping permanently disabled
149 #define DF_INOS_AXIS_FLAG_RNDNR 0x00000200 // axis has random number
150 #define DF_INOS_AXIS_FLAG_PWCL 0x00000400 // limits are checked in post write
151 #define DF_INOS_AXIS_FLAG_DSAP 0x00000800 // disable SetAct/SetRealPosition in case of synched
152 #define DF_INOS_AXIS_FLAG_SAFETY 0x00001000 // powered by Indel safety
153 #define DF_INOS_AXIS_FLAG_ESPULL 0x00002000 // emergency stop pull in case of an axis error
154 #define DF_INOS_AXIS_FLAG_IGNORE_CORE 0x00004000 // ignore core mismatch failure (should only be used in desperate situations)
155 #define DF_INOS_AXIS_FLAG_INPUT_SHAPING_ACTIVE 0x20000000 // temporary input shaping active
156 #define DF_INOS_AXIS_FLAG_WINDOW 0x40000000 // temporary position window active
157 #define DF_INOS_AXIS_FLAG_SNCD 0x80000000 // axis is synced
158 //
159 // --- axis sync modes ---------------------------------------------------------
160 //
161 #define DF_INOS_AXIS_SYNC_NOADJ 0x00 // live sync with no move adjust
162 #define DF_INOS_AXIS_SYNC_ADJUST 0x01 // live sync with move adjust
163 #define DF_INOS_AXIS_SYNC_STOP 0x02 // live sync with stop at sync
164 //
165 // --- axis norm modes ---------------------------------------------------------
166 //
171 #define DF_INOS_AXIS_NORM_AFTER 0x00
172 
174 #define DF_INOS_AXIS_NORM_LIVE 0x01
175 
177 #define DF_INOS_AXIS_NORM_POSITIVE 0x40
178 
182 #define DF_INOS_AXIS_NORM_ROUND 0x80
183 //
184 // --- axis moving direction in norm mode --------------------------------------
185 //
188 #define DF_INOS_AXIS_NORM_MOVE_DIR_NO 0x00
189 
193 #define DF_INOS_AXIS_NORM_MOVE_DIR_POS 0x01
194 
198 #define DF_INOS_AXIS_NORM_MOVE_DIR_NEG 0x02
199 
203 #define DF_INOS_AXIS_NORM_MOVE_DIR_SHORT 0x03
204 
209 #define DF_INOS_AXIS_NORM_MOVE_DIR_SHORT_EX 0x04
210 //
211 // --- axis safety types -------------------------------------------------------
212 //
216 #define DF_INOS_AXIS_SAFETY_EMGSTOP 0x00
217 
221 #define DF_INOS_AXIS_SAFETY_AUTO 0x01
222 
224 #define DF_INOS_AXIS_SAFETY_NONE 0x02
225 //
226 // --- axis emergency types ----------------------------------------------------
227 //
232 #define DF_INOS_AXIS_EMGT_STOP 0x00
233 
238 #define DF_INOS_AXIS_EMGT_STOP_INACTIVATE 0x01
239 
241 #define DF_INOS_AXIS_EMGT_INACTIVATE 0x02
242 
245 #define DF_INOS_AXIS_EMGT_NONE 0x03
246 
251 #define DF_INOS_AXIS_EMGT_STOP_POSITION 0x04
252 
257 #define DF_INOS_AXIS_EMGT_STOP_POSITION_INACTIVATE 0x05
258 //
259 // --- emergency stop special values -------------------------------------------
260 //
261 #define DF_PRECONFIGURED_EME_STOP_TYPE 0xffff // preconfigured (by dt2 or via inco variable) emergency stop type
262 
265 #define DF_PRECONFIGURED_EME_STOP_POS_OR_STOP 0xfffe
266 #define DF_PRECONFIGURED_EME_STOP_DELAY 0xffff // preconfigured (by dt2 or via inco variable) emergency stop delay
267 //
268 // --- positioning type --------------------------------------------------------
269 //
272 #define DF_INOS_AXIS_PST_STANDARD 0x00000000
273 
277 #define DF_INOS_AXIS_PST_WINDOW 0x00000001
278 
283 #define DF_INOS_AXIS_PST_WINDOW_OPT 0x00000002
284 //
285 // --- axis options ------------------------------------------------------------
286 //
291 #define DF_INOS_BASE_AXIS_OPT_EARLY_DONE 0x00000001
292 
298 #define DF_INOS_BASE_AXIS_OPT_AUTO_ACCEPT 0x00000002
299 
302 #define DF_INOS_BASE_AXIS_OPT_LIMITS_IF_SNCD 0x00000004
303 
307 #define DF_INOS_BASE_AXIS_OPT_MAPPING_DISABLED 0x00000008
308 
312 #define DF_INOS_BASE_AXIS_OPT_NORM_ENABLED 0x00000010
313 
317 #define DF_INOS_BASE_AXIS_OPT_CHECK_LIMITS 0x00000020
318 
322 #define DF_INOS_BASE_AXIS_OPT_LIFETIME 0x00000040
323 
327 #define DF_INOS_BASE_AXIS_OPT_SETPOS_DISABLED 0x00000080
328 
332 #define DF_INOS_BASE_AXIS_OPT_EMGSTOP_PULL 0x00000100
333 
335 #define DF_INOS_BASE_AXIS_OPT_FORCE_CONTROL 0x00000200
336 
339 #define DF_INOS_BASE_AXIS_OPT_IGNORE_CORE 0x00000400
340 
341 #if defined(INOS_MOTORCONFIG_LOAD_SUPPORT)
342 
348 #define DF_INOS_BASE_AXIS_OPT_CPF_UNIQUE 0x00000800
349 #endif
350 
351 // --- axis limit errors -------------------------------------------------------------
352 //
353 #define DF_INOS_BASE_AXIS_LIMIT_S 0x00000001 // position limit of cmdS exceeded
354 #define DF_INOS_BASE_AXIS_LIMIT_V_OF_S 0x00000002 // velocity limit of cmdS exceeded
355 #define DF_INOS_BASE_AXIS_LIMIT_A_OF_S 0x00000004 // accelleration ity limit of cmdS exceeded
356 #define DF_INOS_BASE_AXIS_LIMIT_B_OF_S 0x00000008 // de-accelleration ity limit of cmdS exceeded
357 #define DF_INOS_BASE_AXIS_LIMIT_S_V_CONS 0x00000010 // consistency error between S and V
358 #define DF_INOS_BASE_AXIS_LIMIT_V 0x00000020 // velocity limit of cmdV exceeded
359 #define DF_INOS_BASE_AXIS_LIMIT_A_OF_V 0x00000040 // accelleration ity limit of cmdV exceeded
360 #define DF_INOS_BASE_AXIS_LIMIT_B_OF_V 0x00000080 // de-accelleration ity limit of cmdV exceeded
361 #define DF_INOS_BASE_AXIS_LIMIT_A 0x00000100 // accelleration ity limit of cmdA exceeded
362 #define DF_INOS_BASE_AXIS_LIMIT_B 0x00000200 // de-accelleration ity limit of cmdA exceeded
363 #define DF_INOS_BASE_AXIS_LIMIT_BRAKE 0x00000400 // axis cannot stop within bordes
364 #define DF_INOS_BASE_AXIS_LIMIT_J_OF_S 0x00000800 // jerk limit of cmdS exceeded
365 #define DF_INOS_BASE_AXIS_LIMIT_J_OF_V 0x00001000 // jerk limit of cmdV exceeded
366 #define DF_INOS_BASE_AXIS_LIMIT_J_OF_A 0x00002000 // jerk limit of cmdA exceeded
367 #define DF_INOS_BASE_AXIS_LIMIT_J 0x00004000 // jerk limit of cmdJ exceeded
368 
369 //
370 //------------------------------------------------------------------------------
371 // includes
372 //------------------------------------------------------------------------------
373 //
374 // system
375 #include <cinosbus.h>
376 #include <cinosbaseramp.h>
377 #if defined(INOS_AXIS_EXTENSION_SUPPORT)
378 #include <cinosbaseaxisextension.h>
379 #endif
380 //
381 // C++
382 //
383 // project
384 //
385 //------------------------------------------------------------------------------
386 //--- structures ---------------------------------------------------------------
387 //------------------------------------------------------------------------------
388 
393 struct SINOSBaseAxis
394 {
397  inosName64 m_cName;
398 
403  inosName32 m_cRampType;
404 
410  uint16 m_uNumber;
411 
415  uint8 m_uCoreId;
416 
419  uint8 m_uReserved;
420 
432  uint32 m_uOptions;
433 
439  uint8 m_uSafetyType;
440 
451  uint8 m_uEmergencyType;
452 
456  uint16 m_uEmergencyDelay;
457 
462  uint32 m_uTestDelay;
463 
466  real64 m_rTestPos1;
467 
470  real64 m_rTestPos1Max;
471 
474  real64 m_rTestPos2;
475 
478  real64 m_rTestPos2Max;
479 
483  real64 m_rEmergencyPosition;
484 
487  real64 m_rTrackFactor;
488 
491  uint32 m_uTrackFilterLength;
492 
500  uint32 m_uPosType;
501 
505  uint32 m_uPosTime;
506 
510  uint32 m_uPosTimeout;
511 
515  real64 m_rPosTolerance;
516 
520  uint32 m_uCacheSize;
521 
525  uint16 m_cShort;
526 
534  uint8 m_uNormMode;
535 
544  uint8 m_uNormMoveDir;
545 
548  real64 m_rNormPos;
549 
555  inosName32 m_cDefaultParam;
556 
559  inosName32 m_cEmergencyParam;
560 
563  inosName64 m_cDescription;
564 
565  // constructor
566  SINOSBaseAxis();
567 };
568 
569 //------------------------------------------------------------------------------
570 // forward declarations
571 //------------------------------------------------------------------------------
572 //
573 class CINOSMoveCache;
574 class CINOSBaseAxis;
575 class CINOSLimitChecker;
576 //
577 //------------------------------------------------------------------------------
578 // class definition
579 //------------------------------------------------------------------------------
580 
582 class CINOSBaseAxisParamSet
583 {
584  //--- user interface ---------------------------------------------------
585 
586  // public member functions
587  public :
588  virtual uint32 SetParam(const char* apName, real64 arValue);
589  //; universal set parameter with aName to aValue and return error code
590  //; \return 0 on success, an INCO error code otherwise, such as
591  //; defVarNotFound, defVarReadOnly, etc.
592  virtual uint32 GetParam(const char* apName, real64& arResult);
593  //; universal get parameter with aName to aResult and return error code
594  virtual CINCOObject* GetRegister(CINOSBaseAxis* apAxis);
595  //; On the first invocation, this function creates the INCO tree
596  //; for this object. Subsequent invocations just return the
597  //; previously created tree.
598  //; return pointer to my inco object
599  virtual CINCOObject* GetRegister() const;
600  //; \return Pointer to my INCO object (or NULL if non have been
601  //; created so far). This function doesn't create any INCO items,
602  //; it just returns what's currently there.
603  SINOSRampParam* GetRampParam()
604  { return &m_pRamp->m_Param;};
605 
606  #if defined(INOS_AXIS_EXTENSION_SUPPORT)
607  void AddExtension(SINOSParamSetExtension* apExtension);
610  void RemoveExtension(const char* apName);
611  #endif
612 
613  //--- internals --------------------------------------------------------
614 
615  // my axis is my friend
616  friend class CINOSBaseAxis;
617  friend class CINOSPhysicalAxis;
618  friend class CINOSShape;
619 
620  // public but just for internal use
621  public:
625  CINOSBaseAxisParamSet& operator=(const CINOSBaseAxisParamSet& aOther);
626  int operator < (CINOSBaseAxisParamSet& aSet) const
627  { return (strcmp(m_cName, aSet.m_cName)<0);}
628  int operator == (CINOSBaseAxisParamSet& aSet) const
629  { return (strcmp(m_cName, aSet.m_cName)==0);}
630  int operator < (const char* apName) const
631  { return (strcmp(m_cName, apName)<0);}
632  int operator == (const char* apName) const
633  { return (strcmp(m_cName, apName)==0);}
634  friend int operator == (CINOSBaseAxisParamSet& aSet1, CINOSBaseAxisParamSet& aSet2)
635  { return (strcmp(aSet1.m_cName, aSet2.m_cName)==0);}
636 
637  // public but just for internal use
638  public:
639  explicit CINOSBaseAxisParamSet(const char* apName);
640  //; constructor
641  CINOSBaseAxisParamSet(const CINOSBaseAxisParamSet& aOther);
642  //; copy constructor, creates deep copies of the values. Note
643  //; that m_pRegister will not be copied nor created. The caller
644  //; would need to call GetRegister() to create the INCO
645  //; representation
646  virtual ~CINOSBaseAxisParamSet();
647  //; destructor
648 
649  // protected members
650  protected:
651  inosName64 m_cName;
652  //; set name
653  CINCOObject* m_pRegister;
654  //; pointer to inco registration of set
655  CINOSBaseRampParamSet* m_pRamp;
656  //; pointer to ramp param set
657  uint32 m_uPosType;
658  //; positioning type [0-standard, 1-window]
659  uint32 m_uPosTime;
660  //; positioning time [ms]
661  uint32 m_uPosTimeout;
662  //; positioning timeout [ms]
663  real64 m_rPosTolerance;
664  //; positioning tolerance [unit]
665 
666  // allow dynamic object handling (new/delete)
667  DECLARE_DYNAMIC(CINOSBaseAxisParamSet);
668 };
670 
671 //------------------------------------------------------------------------------
672 // class definition
673 //------------------------------------------------------------------------------
674 //
675 typedef real64 (*tpGetter)(void* apVal);
676 
677 struct SINOSBaseAxisHook;
678 class CINOSMapping;
679 class CINOSBaseAxis
680 {
681  //--- user interface ---------------------------------------------------
682 
683  // public member functions
684  public :
685 
690  explicit CINOSBaseAxis(SINOSBaseAxis* apDesc);
691 
698  CINOSBaseAxis(SINOSBaseAxis* apDesc, CINOSBaseRamp* apRamp);
699 
702  virtual ~CINOSBaseAxis();
703 
708  static CINOSBaseAxis* GetAxis(const char* apAxisName);
709 
714  static CINOSBaseAxis* GetAxis(uint32 auNumber)
715  {
716  if (auNumber < DF_INOS_MAX_AXIS)
717  return m_pAxis[auNumber];
718  else
719  return nullptr;
720  }
721 
726  static uint8 GetNumber(const char* apAxisName);
727  //; return number of axis apAxis
728 
736  virtual uint32 WaitTicks(uint32 auTicks = 1);
737 
741  virtual uint32 Connect()
742  { return 0; };
743 
749  virtual uint32 Enable(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
750 
756  virtual uint32 Disable(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
757 
759  void InitializeLimitChecker();
760 
761 
771  virtual uint32 Activate(bool abCheckPos = true, bool abSimulatePos = false,
772  bool abSimulateOut = false, bool abSimulateAct = false,
773  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
774 
779  virtual uint32 InActivate(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
780 
786  virtual uint32 Relax(uint32 auTimeMs, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
787 
794  virtual uint32 Sync(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
795 
804  virtual uint32 Sync(real64 arPosition, SINOSRampParam* apParam,
805  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
806 
814  virtual uint32 Sync(real64 arPosition, const char* apParam,
815  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
816 
824  virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
825  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
826 
836  virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
837  SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
838 
847  virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
848  const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
849 
857  virtual uint32 Sync(real64 arSyncPos, const char* apParam, CINCOObject* apObject,
858  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
859 
866  virtual uint32 Move(real64 arPosition,
867  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
868 
876  virtual uint32 Move(real64 arPosition, SINOSRampParam* apParam,
877  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
878 
885  virtual uint32 Move(real64 arPosition, const char* apParam,
886  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
887 
898  virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5 = true,
899  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
900 
913  virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5,
914  SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
915 
927  virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5,
928  const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
929 
944  virtual uint32 Move(real64 arPosition, real64 arSafe1, real64 arSafe2,
945  SINOSRampParam* apParam1, SINOSRampParam* apParam2, real64 arPartner, SINOSRampParam* apPartner,
946  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
947 
961  virtual uint32 Move(real64 arPosition, real64 arSave1, real64 arSave2,
962  const char* apParam1, const char* apParam2, real64 arPartner, const char* apPartner,
963  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
964 
975  virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
976  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
977 
992  virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
993  SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
994 
1009  virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1010  const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1011 
1025  virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1026  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1027 
1042  virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1043  SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1044 
1059  virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
1060  const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
1061 
1068  virtual uint32 Toggle(real64 arPosition1, real64 arPosition2);
1069 
1080  virtual uint32 ToggleSection(real64 arPos1Min, real64 arPos1Max,
1081  real64 arPos2Min, real64 arPos2Max, uint32 auDelayMin, uint32 auDelayMax);
1082 
1091  virtual uint32 Track(const char* apVarName, real64 arFactor,
1092  uint32 auFilterLength, uint32 auDirection = 0);
1093 
1103  virtual uint32 Track(const char* apVarName, real64 arFactor,
1104  uint32 auFilterLength, uint32 auDirection, const char* apParam);
1105 
1115  virtual uint32 Track(const char* apVarName, real64 arCmdValue,
1116  real64 arFactor, uint32 auFilterLength);
1117 
1122  virtual uint32 SetTrackFactor(real64 arFactor);
1123 
1129  virtual uint32 Endless(bool abPositive = true);
1130 
1138  virtual uint32 Endless(bool abPositive, SINOSRampParam* apParam,
1139  CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1140 
1147  virtual uint32 Endless(bool abPositive, const char* apParam,
1148  CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1149 
1156  virtual uint32 Cursor(bool abPositive = true);
1157 
1164  virtual uint32 Cursor(real64 arPosition);
1165 
1173  virtual uint32 Cursor(bool abPositive, uint32 auWaitTime);
1174 
1181  virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime);
1182 
1191  virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
1192  real64 arStep);
1193 
1202  virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime,
1203  real64 arStep);
1204 
1214  virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
1215  real64 arStep, SINOSRampParam* apParam);
1216 
1226  virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime,
1227  real64 arStep, SINOSRampParam* apParam);
1228 
1238  virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
1239  real64 arStep, const char* apParam);
1240 
1250  virtual uint32 Cursor(real64 arbPosition, uint32 auWaitTime,
1251  real64 arStep, const char* apParam);
1252 
1258  virtual uint32 Update(CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1259 
1266  virtual uint32 Update(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1267 
1274  virtual uint32 Update(const char* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1275 
1280  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition);
1281 
1286  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, SINOSRampParam* apParam);
1287 
1292  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, const char* apParam);
1297  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta);
1302  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta,
1303  SINOSRampParam* apParam);
1308  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta, const char* apParam);
1313  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
1314  real64 arDelta);
1319  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
1320  real64 arDelta, SINOSRampParam* apParam);
1325  virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
1326  real64 arDelta, const char* apParam);
1327 
1332  virtual real64 GetMoveTime(real64 arPosition);
1333 
1338  virtual real64 GetAccelerationTime(real64 arPosition);
1339 
1344  virtual real64 GetConstTime(real64 arPosition);
1345 
1350  virtual real64 GetDecelerationTime(real64 arPosition);
1351 
1357  virtual real64 GetMoveTime(real64 arPosition, SINOSRampParam* apParam);
1358 
1364  virtual real64 GetAccelerationTime(real64 arPosition, SINOSRampParam* apParam);
1365 
1371  virtual real64 GetConstTime(real64 arPosition, SINOSRampParam* apParam);
1372 
1378  virtual real64 GetDecelerationTime(real64 arPosition, SINOSRampParam* apParam);
1379 
1385  virtual real64 GetMoveTime(real64 arPosition, const char* apParam);
1386 
1392  virtual real64 GetAccelerationTime(real64 arPosition, const char* apParam);
1393 
1399  virtual real64 GetConstTime(real64 arPosition, const char* apParam);
1400 
1406  virtual real64 GetDecelerationTime(real64 arPosition, const char* apParam);
1407 
1413  virtual real64 GetMoveTime(real64 arPosition, real64 arDelta);
1414 
1420  virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta);
1421 
1427  virtual real64 GetConstTime(real64 arPosition, real64 arDelta);
1428 
1434  virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta);
1435 
1442  virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1443 
1450  virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1451 
1458  virtual real64 GetConstTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1459 
1466  virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1467 
1474  virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, const char* apParam);
1475 
1482  virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, const char* apParam);
1483 
1490  virtual real64 GetConstTime(real64 arPosition, real64 arDelta, const char* apParam);
1491 
1498  virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, const char* apParam);
1499 
1507  virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
1508  real64 arDelta);
1509 
1517  virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
1518  real64 arDelta);
1519 
1527  virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
1528  real64 arDelta);
1529 
1537  virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
1538  real64 arDelta);
1539 
1548  virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
1549  real64 arDelta, SINOSRampParam* apParam);
1550 
1559  virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
1560  real64 arDelta, SINOSRampParam* apParam);
1561 
1570  virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
1571  real64 arDelta, SINOSRampParam* apParam);
1572 
1581  virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
1582  real64 arDelta, SINOSRampParam* apParam);
1583 
1592  virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
1593  real64 arDelta, const char* apParam);
1594 
1603  virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
1604  real64 arDelta, const char* apParam);
1605 
1614  virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
1615  real64 arDelta, const char* apParam);
1616 
1625  virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
1626  real64 arDelta, const char* apParam);
1627 
1635  virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1636  real64 arVelocity);
1637 
1646  virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1647  real64 arVelocity, SINOSRampParam* apParam);
1648 
1657  virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1658  real64 arVelocity, const char* apParam);
1659 
1668  virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1669  real64 arVelocity, real64 arDelta);
1670 
1680  virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1681  real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1682 
1692  virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
1693  real64 arVelocity, real64 arDelta, const char* apParam);
1694 
1704  virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
1705  real64 arPositionVel, real64 arVelocity, real64 arDelta);
1706 
1717  virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
1718  real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1719 
1730  virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
1731  real64 arPositionVel, real64 arVelocity, real64 arDelta, const char* apParam);
1732 
1740  virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1741  real64 arVelocity);
1742 
1751  virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1752  real64 arVelocity, SINOSRampParam* apParam);
1753 
1762  virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1763  real64 arVelocity, const char* apParam);
1764 
1773  virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1774  real64 arVelocity, real64 arDelta);
1775 
1785  virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1786  real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1787 
1797  virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
1798  real64 arVelocity, real64 arDelta, const char* apParam);
1799 
1809  virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
1810  real64 arPositionVel, real64 arVelocity, real64 arDelta);
1811 
1822  virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
1823  real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
1824 
1835  virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
1836  real64 arPositionVel, real64 arVelocity, real64 arDelta, const char* apParam);
1837 
1842  virtual int32 GetMoveTicks(real64 arPosition);
1843 
1848  virtual int32 GetAccelerationTicks(real64 arPosition);
1849 
1854  virtual int32 GetConstTicks(real64 arPosition);
1855 
1860  virtual int32 GetDecelerationTicks(real64 arPosition);
1861 
1867  virtual int32 GetMoveTicks(real64 arPosition, SINOSRampParam* apParam);
1868 
1874  virtual int32 GetAccelerationTicks(real64 arPosition, SINOSRampParam* apParam);
1875 
1881  virtual int32 GetConstTicks(real64 arPosition, SINOSRampParam* apParam);
1882 
1888  virtual int32 GetDecelerationTicks(real64 arPosition, SINOSRampParam* apParam);
1889 
1895  virtual int32 GetMoveTicks(real64 arPosition, const char* apParam);
1896 
1902  virtual int32 GetAccelerationTicks(real64 arPosition, const char* apParam);
1903 
1909  virtual int32 GetConstTicks(real64 arPosition, const char* apParam);
1910 
1916  virtual int32 GetDecelerationTicks(real64 arPosition, const char* apParam);
1917 
1923  virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta);
1924 
1930  virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta);
1931 
1937  virtual int32 GetConstTicks(real64 arPosition, real64 arDelta);
1938 
1944  virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta);
1945 
1952  virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1953 
1960  virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1961 
1968  virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1969 
1976  virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
1977 
1984  virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, const char* apParam);
1985 
1992  virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, const char* apParam);
1993 
2000  virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, const char* apParam);
2001 
2008  virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, const char* apParam);
2009 
2017  virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
2018  real64 arDelta);
2019 
2027  virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
2028  real64 arDelta);
2029 
2037  virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
2038  real64 arDelta);
2039 
2047  virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
2048  real64 arDelta);
2049 
2058  virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
2059  real64 arDelta, SINOSRampParam* apParam);
2060 
2069  virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
2070  real64 arDelta, SINOSRampParam* apParam);
2071 
2080  virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
2081  real64 arDelta, SINOSRampParam* apParam);
2082 
2091  virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
2092  real64 arDelta, SINOSRampParam* apParam);
2093 
2102  virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
2103  real64 arDelta, const char* apParam);
2104 
2113  virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
2114  real64 arDelta, const char* apParam);
2115 
2124  virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
2125  real64 arDelta, const char* apParam);
2126 
2135  virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
2136  real64 arDelta, const char* apParam);
2137 
2141  virtual int32 GetExitTicks();
2142 
2147  virtual real64 GetMoveDist(real64 arTime);
2148 
2154  virtual real64 GetMoveDist(real64 arPosition, real64 arTime);
2155 
2161  virtual real64 GetMoveDist(real64 arTime, SINOSRampParam* apParam);
2162 
2169  virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
2170  SINOSRampParam* apParam);
2171 
2177  virtual real64 GetMoveDist(real64 arTime, const char* apParam);
2178 
2185  virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
2186  const char* apParam);
2187 
2193  virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks);
2194 
2201  virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks,
2202  SINOSRampParam* apParam);
2203 
2210  virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks,
2211  const char* apParam);
2212 
2220  virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2221  real64 arTime);
2222 
2231  virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2232  real64 arTime, SINOSRampParam* apParam);
2233 
2242  virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2243  real64 arTime, const char* apParam);
2244 
2252  virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2253  uint32 auTicks);
2254 
2263  virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2264  uint32 auTicks, SINOSRampParam* apParam);
2265 
2274  virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
2275  uint32 auTicks, const char* apParam);
2276 
2280  virtual uint64 GetStartTicks(real64 arDelta);
2281 
2285  virtual uint64 GetTargetTicks();
2286 
2290  virtual uint64 GetTargetTicks(real64 arDelta);
2291 
2297  virtual uint32 SegBegin(real64 arSlowMotion = REAL64(1.0), real64 arStartVelocity = REAL64(0.0));
2298 
2305  virtual uint32 SegBegin(real64 arSlowMotion, real64 arStartPosition, real64 arStartVelocity);
2306 
2312  virtual uint32 SegMove(real64 arPosition);
2313 
2320  virtual uint32 SegMove(real64 arPosition, SINOSRampParam* apParam);
2321 
2328  virtual uint32 SegMove(real64 arPosition, const char* apParam);
2329 
2336  virtual uint32 SegMove(real64 arPosition, real64 arVelocity);
2337 
2345  virtual uint32 SegMove(real64 arPosition, real64 arVelocity,
2346  SINOSRampParam* apParam);
2347 
2355  virtual uint32 SegMove(real64 arPosition, real64 arVelocity,
2356  const char* apParam);
2357 
2362  virtual uint32 SegConst(real64 arPosition);
2363 
2368  virtual uint32 SegPos(real64 arTime);
2369 
2375  virtual uint32 SegPosSetTime(real64 arTime);
2376 
2382  virtual uint32 SegVelocity(real64 arVelocity, SINOSRampParam* apParam);
2383 
2389  virtual uint32 SegVelocity(real64 arVelocity, const char* apParam);
2390 
2394  virtual real64 SegTime();
2395 
2400  virtual uint32 SegRun(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2401 
2405  virtual uint32 WaitInPosition();
2406 
2410  virtual uint32 GetBusTicksPerAxisTick();
2411 
2412  // pulling
2413 
2424  virtual uint32 Pull(real64 arS, real64 arV, real64 arA, real64 arJ);
2425 
2434  virtual uint32 Pull(SINOSRampData& aData);
2435 
2445  virtual uint32 Pull(SINOSRampDataEx* apData);
2446 
2450  void EnableRamp()
2451  {
2452  // enable trajectory generator
2453  m_pRamp->Enable();
2454  };
2455 
2460  void DisableRamp()
2461  {
2462  // disable trajectory generator
2463  m_pRamp->Disable();
2464  };
2465 
2466  // stop/break/continue functions
2467 
2472  virtual uint32 Stop(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2473 
2479  virtual uint32 Stop(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2480 
2486  virtual uint32 Stop(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2487 
2493  virtual uint32 Stop(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2494 
2501  virtual uint32 Stop(real64 arPosition, SINOSRampParam* apParam,
2502  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2503 
2510  virtual uint32 Stop(real64 arPosition, const char* apParam,
2511  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2512 
2519  virtual uint32 StopLive();
2520 
2529  virtual uint32 StopLive(real64 arSlowMotion, SINOSRampParam* apParam);
2530 
2540  virtual uint32 StopLiveDelta(real64 arDelta, real64 arSlowMotion, SINOSRampParam* apParam = nullptr);
2541 
2548  virtual uint32 Break(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2549 
2557  virtual uint32 Break(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2558 
2566  virtual uint32 Break(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2567 
2575  virtual uint32 Break(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2576 
2585  virtual uint32 Break(real64 arPosition, SINOSRampParam* apParam,
2586  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2587 
2596  virtual uint32 Break(real64 arPosition, const char* apParam,
2597  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2598 
2604  virtual uint32 Continue(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2605 
2612  virtual uint32 Continue(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2613 
2620  virtual uint32 Continue(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2621 
2626  virtual uint32 EmergencyStop(CINOSSync* apSync);
2627 
2634  virtual uint32 EmergencyStop(uint16 auType = DF_PRECONFIGURED_EME_STOP_TYPE, uint16 auDelay = DF_PRECONFIGURED_EME_STOP_DELAY,
2635  CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
2636 
2643  virtual uint32 EmergencyStopLive();
2644 
2653  virtual uint32 EmergencyStopLive(uint16 auType, uint16 auDelay = DF_PRECONFIGURED_EME_STOP_DELAY);
2654 
2655  // get/set property functions
2656 
2668  virtual const char* GetName();
2669  //; return axis name
2670  virtual const char* GetType();
2671  //; return axis type
2672  virtual const char* GetUnit();
2673  //; return axis unit
2674  virtual uint32 GetCharacteristics();
2675  //; return axis characteristics
2676  virtual uint8 GetNumber()
2677  //; return axis number
2678  { return (uint8) m_pDesc->m_uNumber;};
2679  virtual uint32 GetOptions()
2680  //; return axis options
2681  { return m_pDesc->m_uOptions;};
2682  virtual char GetShort()
2683  //; return axis short character
2684  { return m_cShort[0];};
2685  virtual void SetShort(char acShort)
2686  //; set axis short character
2687  { m_cShort[0] = acShort;};
2688  virtual void SetPartner(const char* apPartner);
2689  //; set partner axis (used for special move commands)
2690  virtual void SetPartner(CINOSBaseAxis* apPartner);
2691  //; set partner axis (used for special move commands)
2692  virtual void SetCmdPosition(real64 arPosition);
2693  //; set commanded axis position (see comment above)
2694  virtual void SetPathPosition(real64 arPosition){};
2695  //; set commanded path axis position
2696  virtual void GetCmdPosition(real64& arPosition);
2697  //; get commanded axis position (see comment above)
2698  virtual void SetCmdVelocity(real64 arVelocity);
2699  //; set commanded velocity (see comment above)
2700  virtual void GetCmdVelocity(real64& arVelocity, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
2701  //; get commanded velocity (see comment above)
2702  virtual void SetCmdAcceleration(real64 arAcceleration);
2703  //; set commanded acceleration (see comment above)
2704  virtual void GetCmdAcceleration(real64& arAcceleration, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
2705  //; get commanded acceleration (see comment above)
2706  virtual void SetCmdDeceleration(real64 arDeceleration);
2707  //; set commanded deceleration (see comment above)
2708  virtual void GetCmdDeceleration(real64& arDeceleration, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
2709  //; get commanded deceleration (see comment above)
2710  virtual void SetCmdCruiseleration(real64 arCruiseleration);
2711  //; set commanded cruiseleration (see comment above)
2712  virtual void GetCmdCruiseleration(real64& arCruiseleration);
2713  //; get commanded cruiseleration (see comment above)
2714  virtual void SetCmdJerk(real64 arJerk, uint32 auNumber = DF_INOS_RAMP_JERK_ALL);
2715  //; set commanded jerk (see comment above)
2716  virtual void GetCmdJerk(real64& arJerk, uint32 auNumber = 0);
2717  //; get commanded jerk (see comment above)
2718  virtual void SetCmdCruiseJerk(real64 arCruiseJerk);
2719  //; set commanded cruise jerk (see comment above)
2720  virtual void GetCmdCruiseJerk(real64& arCruiseJerk);
2721  //; get commanded cruise jerk (see comment above)
2722  virtual void GetCmdRealJerk(real64& arJerk, uint32 auNumber = 0);
2723  //; get commanded real jerk (see comment above)
2724  virtual void SetCmdSlowMotion(real64 arSlowMotion, bool abUpdate = false);
2725  //; set commanded slowmotion factor
2726  virtual void GetCmdSlowMotion(real64& arSlowMotion, const char* apParam = 0);
2727  //; get commanded slowmotion factor
2728  virtual void GetActSlowMotion(real64& arSlowMotion, const char* apParam = 0);
2729  //; get actual slowmotion factor (slowmotion>slowmotionmax ? slowmotionmax : slowmotion)
2730  virtual void SetCmdRelaxTime(real64 arRelaxTime);
2731  //; set commanded relax time
2732  virtual void GetCmdRelaxTime(real64& arRelaxTime);
2733  //; get commanded relax time
2734  virtual void SetEmgDeceleration(real64 arDeceleration);
2735  //; set commanded emergency deceleration
2736  virtual void GetEmgDeceleration(real64& arDeceleration);
2737  //; get commanded emergency deceleration
2738  //; get commanded relax time
2739  virtual void SetEmgPosition(real64 arPosition);
2740  //; set emergency position
2741  virtual void GetEmgPosition(real64& arPosition);
2742  //; get emergency position
2743 
2744 
2757  virtual uint32 SetActPosition(real64 arPosition);
2758 
2770  virtual void GetActPosition(real64& arPosition, bool abRamp = true);
2771 
2779  double NormPosition(real64 arPosition) const
2780  {
2781  if (m_uFlag & DF_INOS_AXIS_FLAG_NORM){
2782  // norming active
2783  return iNormPosition(arPosition, m_rNormPos, m_uNormMode & DF_INOS_AXIS_NORM_ROUND);
2784  }
2785  else {
2786  // no norming
2787  return arPosition;
2788  }
2789  }
2790 
2791  virtual void GetActPosition(real64& arPosition, uint64 auTicks);
2792  //; get actual commanded position at bus ticks auTicks
2793  virtual uint32 NrmActPosition(real64 arRange = REAL64(0.0), bool abRound = false);
2794  //; norm actual position
2795  virtual void GetActVelocity(real64& arVelocity, bool abMapped = true);
2796  //; get actual commaned velocity (see comment above)
2797  virtual void GetActAcceleration(real64& arAcceleration, bool abRamp = true);
2798  //; get actual commanded acceleratio (see comment above)n
2799  virtual void GetActJerk(real64& arJerk, bool abRamp = true);
2800  //; get actual commanded jerk (see comment above)
2801  virtual uint32 AdjActTime(real64 arDelta);
2802  //; adjust actual move time
2803 
2819  virtual uint32 SetRealPosition(real64 arPosition);
2820 
2832  virtual void GetRealPosition(real64& arPosition, bool abMapped = true);
2833 
2834  virtual void GetRealVelocity(real64& arVelocity);
2835  //; get real velocity (see comment above)
2836  virtual void GetRealAcceleration(real64& arAcceleration);
2837  //; get real acceleration (see comment above)
2838  virtual void GetRealJerk(real64& arJerk);
2839  //; get real jerk (see comment above)
2840  virtual void GetActPosError(real64& arPosError)
2841  { arPosError = REAL64(0.0);};
2842  //; get actual position error (see comment above)
2843  virtual void GetActVelocityError(real64& arVelocityError, bool abFiltered = false)
2844  { arVelocityError = REAL64(0.0);};
2845  //; get actual position error
2846  virtual void GetUnitsPerInc(double& adUnits);
2847  //; get number of units per one inc
2848  virtual void GetIncsPerUnit(double& adIncs);
2849  //; get number of incs per unit
2850  virtual void SetMinPosition(real64 arPosition);
2851  //; set min. allowed position
2852  virtual void GetMinPosition(real64& apPosition) const;
2853  //; get min. allowed position
2854  virtual void SetMaxPosition(real64 arPosition);
2855  //; set max. allowed position
2856  virtual void GetMaxPosition(real64& arPosition) const;
2857  //; get max. allowed position
2858  virtual bool CheckPosition(real64& arPosition, bool abIgnoreMapping = false, SINOSRampParam* apParam = nullptr);
2859  //; return true if arPosition within the range or no range requested
2860  virtual void SetMinVelocity(real64 arVelocity);
2861  //; set min. allowed velocity
2862  virtual void SetMaxVelocity(real64 arVelocity);
2863  //; set max. allowed velocity
2864  virtual void SetMaxSetupVelocity(real64 arVelocity);
2865  //; set max. allowed velocity in setup mode
2866  virtual void SetMaxInitVelocity(real64 arVelocity);
2867  //; set max. allowed velocity during initialization
2868  virtual void GetMinVelocity(real64& arVelocity);
2869  //; get min. allowed velocity
2870  virtual void GetMaxVelocity(real64& arVelocity, uint32 auFlags = eMaxVelocityNone);
2871  //; get max. allowed velocity
2872  virtual void GetTrqVelocity(real64& arVelocity);
2873  //; get torque velocity
2874  virtual void GetMaxSetupVelocity(real64& arVelocity);
2875  //; get max. allowed velocity in setup mode
2876  virtual void GetMaxInitVelocity(real64& arVelocity);
2877  //; get max. allowed velocity during initialization
2878  virtual void SetMinAcceleration(real64 arAcceleration);
2879  //; set min. allowed acceleration
2880  virtual void SetMaxAcceleration(real64 arAcceleration);
2881  //; set max. allowed acceleration
2882  virtual void SetMaxAccelerationPull(real64 arAcceleration);
2883  //; set max. allowed acceleration during pull
2884  virtual void GetMinAcceleration(real64& arAcceleration);
2885  //; get min. allowed acceleration
2886  virtual void GetMaxAcceleration(real64& arAcceleration);
2887  //; get max. allowed acceleration
2888  virtual void GetMaxAccelerationPull(real64& arAcceleration);
2889  //; get max. allowed acceleration during pull
2890  virtual void GetTrqAcceleration(real64& arAcceleration);
2891  //; get torque acceleration
2892  virtual void SetMinDeceleration(real64 arDeceleration);
2893  //; set min. allowed deceleration
2894  virtual void SetMaxDeceleration(real64 arDeceleration);
2895  //; set max. allowed deceleration
2896  virtual void GetMinDeceleration(real64& arDeceleration);
2897  //; get min. allowed deceleration
2898  virtual void GetMaxDeceleration(real64& arDeceleration);
2899  //; get max. allowed deceleration
2900  virtual void GetTrqDeceleration(real64& arDeceleration);
2901  //; get tourque deceleration
2902  virtual void SetMinCruiseleration(real64 arCruiseleration);
2903  //; set min. allowed cruiseleration
2904  virtual void SetMaxCruiseleration(real64 arCruiseleration);
2905  //; set max. allowed cruiseleration
2906  virtual void GetMinCruiseleration(real64& arCruiseleration);
2907  //; get min. allowed cruiseleration
2908  virtual void GetMaxCruiseleration(real64& arCruiseleration);
2909  //; get max. allowed cruiseleration
2910  virtual void SetMinJerk(real64 arJerk);
2911  //; set min. allowed jerk
2912  virtual void SetMaxJerk(real64 arJerk);
2913  //; set max. allowed jerk
2914  virtual void GetMinJerk(real64& arJerk);
2915  //; get min. allowed jerk
2916  virtual void GetMaxJerk(real64& arJerk);
2917  //; get max. allowed jerk
2918  virtual void GetEpsilon(real64& arEpsilon);
2919  //; get axis epsilon
2920  virtual void GetCycleTime(real64& arCycleTime, bool abOversampled=false);
2921  //; get axis cycle time [sec]
2922  virtual void GetCycleTimeUs(uint32& auCycleTime);
2923  //; get axis cycle time [us]
2924  virtual void GetCycleTimeNs(uint32& auCycleTime);
2925  //; get axis cycle time [ns]
2926  virtual uint8 GetOversampling();
2927  //; get oversampling factor
2928  virtual uint16 GetCycleNumber();
2929  //; get axis cycle number
2930  virtual uint16 GetCycleId();
2931  //; get axis cycle id
2932  virtual void UpdateCycleId(uint16 auCycleId);
2933  //; inform about updated cycle id (core id and cycle number could have changed)
2934  virtual uint8 GetBusId();
2935  //; get axis bus id
2936  virtual uint32 SetParam(const char* apName, real64 arValue);
2937  //; universal set parameter with aName to aValue and return error code
2938  virtual uint32 SetParam(const char* apName, uint64 auValue)
2939  //; universal set parameter with aName to aValue and return error code
2940  { return defVarNotFound;};
2941  virtual uint32 GetParam(const char* apName, real64& arResult);
2942  //; universal get parameter with aName to aResult and return error code
2943  virtual uint32 GetParam(const char* apName, uint64& auResult)
2944  //; universal get parameter with aName to aResult and return error code
2945  { return defVarNotFound;};
2946  virtual volatile real64* GetParamAdr(const char* apName);
2947  //; universal get address of parameter with aName or NULL if not found
2948  void SetFlag(uint32 auFlag)
2949  { INOS_OR(m_uFlag, auFlag);};
2950  //; set axis flags
2951  void ClrFlag(uint32 auFlag)
2952  { INOS_AND(m_uFlag, ~auFlag);};
2953  //; clear axis flags
2954  uint32 GetFlag()
2955  { return m_uFlag & m_uFlagEnb;};
2956  //; get axis flags
2957  void Absolute()
2958  { ClrFlag(DF_INOS_AXIS_FLAG_INCR);};
2959  //; switch to absolute mode
2960  void Incremental()
2961  { SetFlag(DF_INOS_AXIS_FLAG_INCR);};
2962  //; switch to incremental mode
2963  virtual uint32 SetState(uint32 auState);
2964  //; set axis state (used to set from ready to active to be able to force sync)
2965  virtual int32 GetState();
2966  //; get axis state
2967  virtual int32 GetState(uint32& auRampState);
2968  //; get axis and ramp state
2969  const char* GetStateText() const;
2970  //; \return A human readable text describing the current axis state.
2971  virtual bool IsBusy() const;
2972  //; Whether the axis is busy or not. Busy means: The axis is "used"
2973  //; by someone. E.g. the axis is also busy if it's in the "Coupled"
2974  //; state, which means that this axis is the "slave" and therefore
2975  //; it gets its positions/commands from its master axis. The axis
2976  //; is also busy if it is in "break" state (which means it is not
2977  //; currently moving, but it'll continue an already started move
2978  //; later). And it is also 'busy' if it's in "relax" state. In
2979  //; fact, the axis is always busy, unless it is in undefined,
2980  //; disabled, active, peace or read state.
2981  //; return true if the axis is currently busy. false otherwise.
2982  virtual uint32 GetError(bool abResolveExternal = false);
2983  //; get axis error
2984  virtual uint64 GetErrorEx(bool abResolveExternal = false);
2985  //; get extended axis errors
2986  virtual uint32 GetError(uint32& auRampError, bool abResolveExternal = false);
2987  //; get axis and ramp error
2988  virtual uint64 GetErrorEx(uint64& auRampError, bool abResolveExternal = false);
2989  //; get extended axis and ramp error
2990  virtual uint32 GetErrorHook() { return m_uErrorHook; };
2991  //; get axis and ramp error
2992  virtual bool IsErrorFatal()
2993  //; return true if error is fatal
2994  { return false;};
2995  virtual uint32 GetWarning(bool abResolveExternal = false);
2996  //; get axis warning
2997  virtual uint64 GetWarningEx(bool abResolveExternal = false);
2998  //; get extended axis warning
2999  virtual uint32 GetWarning(uint32& auRampWarning, bool abResolveExternal = false);
3000  //; get axis and ramp warning
3001  virtual uint64 GetWarningEx(uint64& auRampWarning, bool abResolveExternal = false);
3002  //; get extended axis and ramp warning
3003  virtual uint32 GetLimitViolation() { return m_uLimitViolation;};
3004  //; get axis limit violation
3005  virtual void SetErrorMask(uint32 auMask) { m_uErrorMask = auMask;};
3006  //; set error mask and return old mask
3007  virtual void SetWarningMask(uint32 auMask) { m_uWarningMask = auMask;};
3008  //; set warning mask and return old mask
3009  virtual void SetLimitViolation(uint32 auLimitViolation)
3010  { INOSOr(&m_uLimitViolation, auLimitViolation);};
3011  //; set axis limit violation
3012  virtual uint32 GetErrorMask() { return m_uErrorMask;};
3013  //; get actual error mask
3014  virtual uint32 GetWarningMask() { return m_uWarningMask;};
3015  //; get actual warning mask
3016  virtual uint32 AcceptError();
3017  //; accept all errors
3018  virtual uint32 AcceptError(uint32 auError);
3019  //; accept error
3020  virtual uint32 AcceptError(uint32 auError, uint32 auRampError);
3021  //; accept error
3022  virtual uint32 AcceptWarning();
3023  //; accept all warnings
3024  virtual uint32 AcceptWarning(uint32 auWarning);
3025  //; accept warning
3026  virtual uint32 AcceptWarning(uint32 auWarning, uint32 auRampWarning);
3027  //; accept warning
3028  virtual uint32 AcceptLimitViolation() { m_uLimitViolation = 0; return 0;};
3029  //; get axis limit violation
3030 
3031  // param set functions
3032  virtual void eCreateParamSet(const char* apSetName);
3033  //; Same as CreateParamSet but for INCO registration (as it doesn't return
3034  //; a pointer)
3035  virtual CINOSBaseAxisParamSet* CreateParamSet(const char* apSetName);
3036  //; create new param set with name apSetName and return pointer to it
3037  virtual void DestroyParamSet(const char* apSetName);
3038  //; destroy param set with name apSetName
3039  virtual bool SelectParamSet(const char* apSetName);
3040  //; select param set with name apSetName
3041 
3042  enum {
3043  eFlgParamSetNone = 0x00000000,
3044  eFlgParamSetSearchGlobal = 0x00000001,
3045  eFlgParamSetIgnoreOverwrite = 0x00000002
3046  };
3047 
3048  virtual CINOSBaseAxisParamSet* GetParamSet(const char* apSetName, uint32 auFlags = eFlgParamSetSearchGlobal);
3049  //; get pointer to param set with name apSetName
3050  virtual SINOSRampParam* GetRampParam(const char* apSetName, uint32 auFlags = eFlgParamSetSearchGlobal);
3051  //; get pointer to ramp param of set apSetName
3052  virtual bool GetRampParam(const char* apSetName, char* apResult, uint32 auSize,
3053  SINOSRampParam& aResult, uint32 auFlags = eFlgParamSetSearchGlobal);
3054  //; copy ramp param data to aResult and return true if successful, copy also to original speed set
3055  //; name to apResult. This method is also able to handle the xxx[V/A/B=yyy] case
3056  virtual void PreDestroyRampParam(SINOSRampParam* apParam);
3057  //; use this method to inform axis, that we're about to destroy a previously
3058  //; used speed set
3059 
3060  static void eCreateGlobalParamSet(const char* apSetName);
3061  //; Same as CreateParamSet but for INCO registration (as it doesn't return
3062  //; a pointer)
3063  static CINOSBaseAxisParamSet* CreateGlobalParamSet(const char* apSetName);
3064  //; create new param set with name apSetName and return pointer to it
3065  static void DestroyGlobalParamSet(const char* apSetName);
3066  //; destroy param set with name apSetName
3067  static CINOSBaseAxisParamSet* GetGlobalParamSet(const char* apSetName);
3068  //; get pointer to param set with name apSetName
3069  static SINOSRampParam* GetGlobalRampParam(const char* apSetName);
3070  //; get pointer to ramp param of set apSetName
3071 
3072  // pos type functions
3073  virtual void SetPosType(uint32 auPosType)
3074  //; set pos type
3075  { m_uPosType = auPosType; };
3076  virtual void SetPosTime(uint32 auPosTime)
3077  //; set pos time
3078  { m_uPosTime = auPosTime; };
3079  virtual void SetPosTimeout(uint32 auPosTimeout)
3080  //; set pos timeout
3081  { m_uPosTimeout = auPosTimeout; };
3082  virtual void SetPosTolerance(real64 arPosTolerance)
3083  //; set pos tolerance
3084  { m_rPosTolerance = arPosTolerance; };
3085 
3086  // param set extensions
3087 
3088  #if defined(INOS_AXIS_EXTENSION_SUPPORT)
3089  SINOSParamSetExtension* GetParamSetExtension(uint32 auExtensionId)
3091  {
3092  // handle over
3093  return m_pRamp->GetParamSetExtension(auExtensionId);
3094  }
3096  real64 GetMoveTimeAdjust(SINOSRampParam* apParam);
3097  #endif
3098 
3099  // caching functions
3100 
3101  void EnableCache(uint32 auSize = 32);
3102  //; create moving cache with size auSize if nessecary and enable it
3103  CINOSRampCache* EnableCache(CINOSRampCache* apCache);
3104  //; set actual moving cache to apCache and return old one or 0
3105  CINOSRampCache* DisableCache();
3106  //; disable moving cache and return old one
3107  void ReEnableCache();
3108  //; Reenables a previously disabled ramp cache. This function is
3109  //; useful if the cache feature has temporarily been disabled
3110  //; before (DisableCache). Note: This function has no effect if
3111  //; the ramp does not yet owns a cache object. Also: It's safe
3112  //; to call this function while the cache is already enabled.
3113  void FlushCache();
3114  //; flush ramp cache
3115  void SetCacheEpsilon(real64 arEpsilon);
3116  //; set new cache 'epsilon' (standard is = 0.0)
3117  #ifdef INOS_MOVE_CACHE_SUPPORT
3118  void FlushMoveCache();
3119  //; flush moving cache
3120  #endif
3121 
3122  // safety
3123 
3124  #ifdef INOS_SAFETY_SUPPORT
3125  virtual void EnableSafetySupervision();
3128  virtual bool DisableSafetySupervision();
3130  virtual void ToggleSafetySupervision();
3131  #endif
3132 
3133  // miscellaneous functions
3134 
3135  virtual CINCOObject* GetRegister();
3136  //; do inco registration and return pointer to it
3137  virtual void SetRamp(CINOSBaseRamp* apRamp);
3138  //; set new ramp geni
3139  CINOSBaseRamp* GetRamp()
3140  { return m_pRamp;};
3141  //; return pointer to ramp geni
3142  virtual CINOSMapping* GetMapping()
3143  { return m_pMapping;};
3144  //; return pointer to actual axis mapping
3145  uint32 GetMappingIndex()
3146  { return m_uMappingIndex;};
3147  //; get actual mapping index
3148 
3149  // miscellaneous functions
3150 
3151  virtual uint32 RegisterHook(uintid& auHookId, void* apHandler, void* apObject,
3152  int32 aiOrder, bool abEnabled=true);
3153  //; register bus hook that runs in the same bus context, core,
3154  //; category, cyclenumber and cycletime as the axis
3155  virtual uint32 UnRegisterHook(uintid auHookId);
3156  //; unregister bus hook
3157  virtual uint32 EnableHook(uintid auHookId);
3158  //; enable hook
3159  virtual uint32 DisableHook(uintid auHookId);
3160  //; disable hook
3161  virtual uint32 RegisterPostHook(uintid& auHookId, void* apHandler, void* apObject,
3162  int32 aiOrder, bool abEnabled=true);
3163  //; register post bus hook that runs in the same bus context, core,
3164  //; category, cyclenumber and cycletime as the axis
3165  virtual uint32 UnRegisterPostHook(uintid auHookId);
3166  //; unregister bus hook
3167  virtual uintid RegisterErrorHook(void* apHandler, void* apObject = 0);
3168  //; register error hook and return hook id
3169  virtual void UnRegisterErrorHook(uintid auHookId);
3170  //; unregister error hook
3171  virtual uintid RegisterWarningHook(void* apHandler, void* apObject = 0);
3172  //; register Warning hook and return hook id
3173  virtual void UnRegisterWarningHook(uintid auHookId);
3174  //; unregister Warning hook
3175  #ifdef INOS_SAFETY_SUPPORT
3176  virtual uintid RegisterSOSHook(void* apHandler, void* apObject = 0);
3177  //; register SOS hook and return hook id
3178  virtual void UnRegisterSOSHook(uintid auHookId);
3179  //; unregister SOS hook
3180  #endif
3181 
3182  #if defined(INOS_AXIS_EXTENSION_SUPPORT)
3183  virtual void RegisterExtension(IINOSBaseAxisExtension* apExtension);
3186  virtual void UnRegisterExtension(IINOSBaseAxisExtension* apExtension);
3187  #endif
3188 
3189  // auto sync
3190 
3191  virtual void EnableSync(real64 arPosition = REAL64(0.0),
3192  uint8 auMode = DF_INOS_AXIS_SYNC_NOADJ){};
3193  //; enable auto syncing (at sync set pos = arPosition)
3194  virtual void DisableSync(){};
3195  //; disable auto syncing
3196  virtual void GetSyncCount(uint32& auSyncCount)
3197  { auSyncCount = 0;};
3198  //; return actual sync counter
3199  virtual void SetSyncCount(uint32 auSyncCount){};
3200  //; set sync counter
3201 
3202  // auto norm
3203 
3224  virtual void EnableNorm(uint8 auMode = DF_INOS_AXIS_NORM_AFTER,
3225  uint8 auMoveDir = DF_INOS_AXIS_NORM_MOVE_DIR_NO,
3226  real64 arNormPos = REAL64(0.0));
3228  virtual void DisableNorm();
3229 
3231  virtual uint8 GetNormMoveDir()
3232  { return m_uNormMoveDir; };
3233 
3235  virtual void SetNormMoveDir(uint8 auNormMoveDir)
3236  { m_uNormMoveDir = auNormMoveDir; };
3237 
3239  virtual uint8 GetNormMode()
3240  { return m_uNormMode; };
3241 
3243  virtual void SetNormMode(uint8 auNormMode)
3244  { m_uNormMode = auNormMode; };
3245 
3246  // current limitation
3247 
3248  virtual void EnableCurLimit(){};
3249  //; enable current limitation
3250  virtual void DisableCurLimit(){};
3251  //; disable current limitation
3252  virtual bool GetCurLimit()
3253  //; return state of current limitation
3254  { return (m_uFlag & DF_INOS_AXIS_FLAG_CURL) != 0;};
3255 
3256  enum EActualType {
3257  eActInput,
3258  eActActual,
3259  eActOutput
3260  };
3262  SINOSRampData* GetActual(EActualType aeType = eActOutput, bool abCopy = true)
3263  {
3264  // check reqeusted type
3265  if (aeType == eActInput) {
3266  // return pointer to ramp values
3267  return m_pActRamp;
3268  } // end if
3269  else if (aeType == eActActual) {
3270  // return pointer to actual values
3271  return m_pActual;
3272  } // end if
3273  else {
3274  // copy requested ?
3275  if (abCopy && (m_pActual == m_pActRamp)) {
3276  // yes
3277  *m_pActControl = *m_pActRamp;
3278  }
3279  // actuals are now control avalues
3280  m_pActual = m_pActControl;
3281  // return pointer to output values
3282  return m_pActControl;
3283  } // end else
3284  };
3286  SINOSRampData* GetRealVrt()
3287  { return m_pRealVrt;};
3289  SINOSRampData* GetActVrt()
3290  { return m_pActRamp;};
3292  SINOSRampData* GetActPhy()
3293  { return GetActual(eActOutput, false);};
3294 
3295  // safety move
3296 
3297  virtual void SetMoveSafeMin(real64 arMin, real64 arFact1=REAL64(0.0),
3298  real64 arFact2=REAL64(0.0));
3299  //; set move safe minimum : arMin=requested minimum,
3300  //; safe1=safe1+arFact(MoveSafeMin-calcedMin), safe2=dito
3301  virtual void ResetMoveSafeMin();
3302  //; reset move safe minimum
3303 
3304  // setup mode
3305 
3306  void EnableSetupMode();
3307  //; enable setup mode
3308  void DisableSetupMode();
3309  //; disable setup mode
3310  virtual bool CheckSetupMode();
3311  //; return true if setup mode active and fullfilled
3312 
3313  #ifdef INOS_USE_CUSTOMER_IMAGE_DATA
3314  void* GetCustomerSpecificData() const { return m_pCustomerSpecificData; }
3315  //; \return The pinter to the customer specific data (or NULL if
3316  //; no such data are set).
3317  void SetCustomerSpecificData(void* apData) { m_pCustomerSpecificData = apData; }
3318  //; Sets apData to be the "customer specific data" of this axis.
3319  //; The function doesn't care about any previously set customer
3320  //; specific data: The caller is 100% responsible for freeing amy
3321  //; resource related to these data!
3322  //; This class will never access the data in any way apart from
3323  //; initialization to NULL during object contstruction!
3324  #endif
3325 
3327  virtual uint32 GetToggleCnt()
3328  { return m_uToggleCnt; };
3330  virtual void SetToggleCnt(uint32 auSetVal)
3331  { m_uToggleCnt=auSetVal; };
3332 
3333  #ifdef INOS_MOVEPATH_SUPPORT
3334  void SetMovePathActuals(struct SINOSMovePathActual* apActuals);
3335  #endif
3336 
3337  // torque limitation
3338 
3340  SINOSBaseRampTrqLimit* GetTrqLimitAcceleration()
3341  { return m_pRamp->GetTrqLimitAcceleration(); };
3343  SINOSBaseRampTrqLimit* GetTrqLimitDeceleration()
3344  { return m_pRamp->GetTrqLimitDeceleration(); };
3345 
3346  // multicore
3347 
3349  uint8 GetCoreId()
3350  { return m_uCoreId; };
3351 
3352  #ifdef INOS_SAFETY_SUPPORT
3353  uint32 GetSafetyUid()
3355  { return m_uSafetyUid; };
3357  uint32 GetSafetyType()
3358  { return m_uSafetyType; };
3360  ESafetyFunction GetSafetyFunction() const {
3361  return m_eSafetyFunction;
3362  }
3363  #endif
3364 
3365  //--- internals --------------------------------------------------------
3366 
3367  // after this function you can register new ramps
3368  friend void _INI_0000_CINOSBaseAxis();
3369  friend void _INI_0400_CINOSBaseAxis();
3370  friend class CINOSRegisterBaseAxis;
3371  friend class CINOSMapping;
3372  friend class CINOSPhysicalAxis;
3373  friend void _INI_0400_INFO_DCM();
3374  friend class CINOSBaseAxisTest;
3375  friend class CINOSMovePathResourcePosAxis;
3376  friend class CINOSMcRobotCmdMove;
3377  friend class CINOSMcRobotCmdInit;
3378  friend class CINOSMcRobotCmdCalib;
3379  friend class CINOSMcTargetAxis;
3380 
3381  // protected member functions
3382  protected:
3383  void Create();
3384  //; create base axis
3385  real64 iNormPosition(real64 arPosition, real64 arRange = REAL64(0.0), bool abRound = false) const;
3386  //; norm arPosition to 0..360
3387  void Signal(CINOSSync*& apSync);
3388  //; signal sync object if requested
3389  virtual void SignalSync(CINOSSync& apSync);
3390  //; signal given sync object
3391  virtual void SetError(uint32 auErrors);
3392  //; set axis error (and call error hook if nessecary)
3393  virtual void SetWarning(uint32 auWarnings);
3394  //; set axis warning (and call warning hook if nessecary)
3395 #ifdef INOS_SAFETY_SUPPORT
3396  virtual void CallSOSHooks();
3397  //; call SOS hooks
3398 #endif // INOS_SAFETY_SUPPORT
3399  bool Enter(uint32 auCommand, CINOSSync* apSync = 0);
3400  //; check if command allowed in current state and return false if not
3401  void Exit ();
3402  //; leave critical section
3403  void Exit (CINOSSync*& apCmdSync, CINOSSync* apSync);
3404  //; leave critical section and wait if nessecary
3405  bool IsCritical()
3406  { return m_CmdLock.GetOwner() != 0;};
3407  //; return true if somebody stays in critical section
3408  virtual void iInActivate();
3409  //; inactivate axis
3410  virtual void iStop(SINOSRampParam* apParam);
3411  //; internal stop
3412  virtual void iEmergencyStop(bool abLive = false);
3413  //; internal emergency stop
3414  virtual uint32 iCursor(bool abPositive, uint32 auWaitTime,
3415  real64 arStep, SINOSRampParam* apParam);
3416  //; internal cursor
3417  virtual uint32 iCursor(real64 arPosition, uint32 auWaitTime,
3418  real64 arStep, SINOSRampParam* apParam);
3419  //; internal cursor
3420  real64 iGetAbsPosition(real64 arRelPosition);
3421  //; get absolute position of arRelPosition
3422  real64 iGetNrmAbsPosition(real64 arRelPosition, SINOSRampParam* apParam = nullptr, bool abConsiderStop = false);
3423  //; get normed absolute position of arRelPosition
3424  virtual void iSetCycleTime(real64 arCycleTime);
3425  //; set axis cycle time [sec]
3426  virtual void iRegisterAxis();
3427  //; register axis
3428  ICACHE virtual void iPreMap();
3429  //; pre mapping handler
3430  ICACHE virtual void iPostMap();
3431 
3432  ICACHE inline void iCheckRampLimits() {
3433  if (m_pRamp->GetError() & ER_INOS_RAMP_VMAX_REACHED) {
3434  SetError(ER_INOS_AXIS_RAMP_LIMIT);
3435  }
3436  }
3437 
3438  //; post mapping handler
3439  ICACHE virtual void iPostWrite();
3440  //; post bus write handler
3441  void SetMapping(CINOSMapping* apMapping, uint32 auIndex)
3442  { m_pMapping = apMapping; m_uMappingIndex = auIndex;
3443  m_pRamp->SetMapping(apMapping, auIndex);};
3444  //; set actual axis mapping
3445  void ResetMapping()
3446  { m_pMapping = 0; m_uMappingIndex = 0;
3447  m_pRamp->ResetMapping();};
3448  //; reset actual axis mapping
3449  virtual bool iInPosition(bool abEarlyDone);
3450  //; returns true if requested position reached
3451  virtual bool iInPosition();
3452  //; returns true if requested position reached (originally, only
3453  //; this overload existed. Then, the abEarlyDone was introduced.
3454  //; Unfortunately, as this function was already 'virtual' we could
3455  //; not just add abEalyDone with a default value, as it would
3456  //; cause derived class, implemented by customers, to not function
3457  //; properly anymore.
3458  virtual void iAdjPreviousPositions(real64 arDifference);
3459  //; adjust previous axis positions (used in limit checker)
3460  virtual void iSetActRampPosition(real64 arPosition);
3461  //; set actual ramp geni position
3462  virtual bool IsCheckPositionRequired();
3463  //; return true if check position required
3464  void SetDefaultParamIfRequired();
3465  //; Sets the "default param" values (V,A,J) to the ramp if those
3466  //; ramp values are current undefined (means: are 0.0). Function does
3467  //; nothing otherwise, or if no "default param" has been specified
3468  //; in the axis config (e.g. in dt2)
3469  void iSetupPositionType(SINOSRampParam* apParam = 0);
3470  //; init position type handling
3471  virtual void iResetTrajectory();
3472  //; reset trajectory planner
3473 
3474  void iCoreMismatchError();
3475  //; set core mismatch axis error
3476 
3477  INOS_INLINE void AtomicEnter(uint32& auToken)
3478  {
3479  CINOSBus* pBus=CINOSBus::FindBus(GetBusId());
3480  if (pBus) {
3481  pBus->AtomicGatherEnter(auToken);
3482  } else {
3483  // no bus -> no token
3484  auToken = 0;
3485  }
3486  }
3487 
3488  INOS_INLINE bool AtomicExit(uint32 auToken)
3489  {
3490  CINOSBus* pBus=CINOSBus::FindBus(GetBusId());
3491  if (pBus) {
3492  return pBus->AtomicGatherExit(auToken);
3493  } else {
3494  // no bus -> always OK
3495  return true;
3496  }
3497  }
3498 
3499  // private member functions (external versions, because until now we are not
3500  // able to register functions with default parameters)
3501  private:
3502  uint32 eEnable();
3503  //; enable axis
3504  uint32 eDisable();
3505  //; disable axis
3506  uint32 eActivate(bool abCheckPos, bool abSimulatePos, bool abSimulateOut,
3507  bool abSimulateAct);
3508  //; activate physical axis
3509  uint32 eInActivate();
3510  //; inactivate physical axis
3511  uint32 eRelax(uint32 auTimeMs);
3512  //; relax coupled axis
3513  uint32 eMove(real64 arPosition);
3514  //; move to position with acc/deceleration and velocity
3515  uint32 eMove(real64 arPosition, char* apParam);
3516  //; move to position with apParam parameters
3517  uint32 eMoveTime(real64 arPosition, real64 arTime);
3518  //; move to position with acc/deceleration and velocity
3519  uint32 eMoveTime(real64 arPosition, real64 arTime, char* apParam);
3520  //; move to position with apParam parameters
3521  uint32 eMoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity);
3522  //; move to position with acc/deceleration and velocity
3523  uint32 eMoveApp(real64 arPosition, real64 aPositionVel, real64 arVelocity, char* apParam);
3524  //; move to position with apParam parameters
3525  uint32 eMoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity);
3526  //; move to position with acc/deceleration and velocity
3527  uint32 eMoveDep(real64 arPosition, real64 aPositionVel, real64 arVelocity, char* apParam);
3528  //; move to position with apParam parameters
3529  uint32 eSync(real64 arPosition);
3530  //; sync axis
3531  uint32 eSync(real64 arPosition, char* apParam);
3532  //; sync axis
3533  uint32 eSync(real64 arPosition, real64 arSyncPosition);
3534  //; sync axis
3535  uint32 eSync(real64 arPosition, real64 arSyncPosition, char* apParam);
3536  //; sync axis
3537  uint32 eCursor();
3538  //; cursor
3539  uint32 eUpdate();
3540  //; update
3541  uint32 eUpdate(const char* apParam);
3542  //; update
3543  uint32 eEndless(bool abPositive);
3544  //; move to position with acc/deceleration and velocity
3545  uint32 eEndless(bool abPositive, const char* aparam);
3546  //; move to position with acc/deceleration and velocity
3547  uint32 eStop();
3548  //; stop
3549  uint32 eStop(const char* apParam);
3550  //; stop
3551  uint32 eStop(real64 arPosition);
3552  //; stop
3553  uint32 eStop(real64 arPosition, const char* apParam);
3554  //; stop
3555  uint32 eBreak();
3556  //; break
3557  uint32 eBreak(const char* apParam);
3558  //; break
3559  uint32 eBreak(real64 arPosition);
3560  //; break
3561  uint32 eBreak(real64 arPosition, const char* apParam);
3562  //; break
3563  uint32 eEmergencyStop();
3564  //; emergency stop
3565  uint32 eEmergencyStop(uint32 auType, uint32 auDelay);
3566  //; emergency stop
3567  uint32 eContinue();
3568  //; stop
3569  uint32 eContinue(const char* apParam);
3570  //; stop
3571  void eSetSlowMotion(real64 arSlowMotion);
3572  //; stop
3573  void ePos1();
3574  //; move to pos 1
3575  void ePos2();
3576  //; move to pos 2
3577  void eToggle();
3578  //; toggle between pos 1 and pos 2
3579  void eZero();
3580  //; set act pos = 0
3581  uint32 eAcceptError();
3582  //; accept all pending errors
3583  uint32 eAcceptWarning();
3584  //; accept all pending warnings
3585  void iToggling();
3586  //; toggle handler (called cyclic)
3587  void iCursoring();
3588  //; toggle handler (called cyclic)
3589  bool iTrack(const char* apVarName, real64 arFactor, uint32 auFilterLength);
3590  //; track the variable apVarName
3591  uint32 _Track(const char* apVarName, real64 arFactor, uint32 auFilter,
3592  uint32 auDirection, SINOSRampParam* apParam);
3593  void iTrackFollow();
3594  //; tracking handler (called cyclic)
3595  void iTrackKeep();
3596  //; tracking handler (called cyclic)
3597 
3598  // protected members
3599  protected:
3600  int32 m_uState;
3601  //; actual state
3602  uint32 m_uSubState;
3603  //; actual sub state
3604  uint32 m_uNxtState;
3605  //; next state
3606  uint32 m_uPrvState;
3607  //; previous state
3608  uint32 m_uBrkState;
3609  //; state before break
3610  uint32 m_uRmpState;
3611  //; state of ramp geni before GetSVAJ
3612  uint32 m_uError;
3613  //; actual errors
3614  uint32 m_uErrorMask;
3615  //; actual error mask
3616  uint32 m_uErrorHook;
3617  //; actual hook error
3618  uint32 m_uWarning;
3619  //; actual warnings
3620  uint32 m_uWarningMask;
3621  //; actual warnings mask
3622  uint32 m_uLimitViolation;
3623  //; actual limit violation mask
3624  uint32 m_uFlag;
3625  //; axis flags (zero, norm, ...)
3626  uint32 m_uFlagEnb;
3627  //; axis flags enable
3628 
3629  const char* m_pName;
3630  //; axis name
3631  const char* m_pType;
3632  //; axis type
3633  char m_cShort[2];
3634  //; short character
3635  CINOSBaseAxis* m_pPartner;
3636  //; pointer to partner axis
3637  CINCOObject* m_pRegister;
3638  //; pointer to inco registration
3639  CINCOObject* m_pCommand;
3640  //; pointer to inco registration of commands
3641  CINCOObject* m_pTest;
3642  //; pointer to inco registration of axis test
3643  CINCOObject* m_pError;
3644  //; pointer to inco registration of axis errors
3645  CINCOObject* m_pWarning;
3646  //; pointer to inco registration of axis warnings
3647  CINCOObject* m_pLimitViolation;
3648  //; pointer to inco registration of limit violations
3649  CINCOObject* m_pFlag;
3650  //; pointer to inco registration of axis flags
3651  CINCOObject* m_pState;
3652  //; pointer to inco registration of axis state
3653  CINOSBaseRamp* m_pRamp;
3654  //; pointer to ramp generator
3655  CINOSLimitChecker* m_pLimitChecker;
3656  //; pointer to limit checker
3657  CINOSMapping* m_pMapping;
3658  //; pointer to actual mapping
3659  uint32 m_uMappingIndex;
3660  //; index this axis has in the actual mapping
3661  SINOSBaseAxis* m_pDesc;
3662  //; pointer to object descriptor
3663  CINOSMutex m_CmdLock;
3664  //; mutex to guarantee mutual exclusion in command handling
3665  CINOSSync* m_pActivate;
3666  //; pointer to synch object to be signaled on end of activate
3667  CINOSSync* m_pInActivate;
3668  //; pointer to synch object to be signaled on end of inactivate
3669  CINOSSync* m_pMove;
3670  //; pointer to synch object to be signaled on end of move
3671  CINOSSync* m_pEndless;
3672  //; pointer to synch object to be signaled on end of endless
3673  CINOSSync* m_pStop;
3674  //; pointer to synch object to be signaled on end of stop
3675  CINOSSync* m_pEmStop;
3676  //; pointer to synch object to be signaled on end of emstop
3677  CINOSSync* m_pBreak;
3678  //; pointer to synch object to be signaled on end of break
3679  CINOSSync* m_pVelocity;
3680  //; pointer to synch object to be signaled on velocity reached
3681  CINOSSync* m_pContinue;
3682  //; pointer to synch object to be signaled on end of continue
3683  CINOSSync* m_pWaitInPosition;
3684  //; pointer to synch object to be signaled on end of waitinposition
3685  CINOSSync* m_pWaitInPositionDyn;
3686  //; pointer to dynamically created synch object to be signaled on end of waitinposition
3687  CINOSSync* m_pWaitTicks;
3688  //; pointer to synch object to be signaled on end of waitticks
3689  uint32 m_uWaitTicks;
3690  //; to to be waited for
3691  uintid m_uPreMapHookId;
3692  //; id of pre map hook
3693  uintid m_uPostMapHookId;
3694  //; id of post map hook
3695  uintid m_uPostWriteHookId;
3696  //; id of post bus write hook
3697  uintid m_uPreHookId;
3698  //; id of pre axis command hooks (e.g. track)
3699  #ifdef INOS_SAFETY_SUPPORT
3700  bool m_bPreHookSafetyEnabled;
3702  #endif
3703  uintid m_uPostHookId;
3704  //; id of post hook command hooks (e.g. toggle)
3705  SINOSBaseAxisHook* m_pErrorHooks;
3706  //; pointer to list of error hooks
3707  SINOSBaseAxisHook* m_pWarningHooks;
3708  //; pointer to list of error hooks
3709  TINOSNameBalancedBinaryTree<CINOSBaseAxisParamSet>* m_pParamSets;
3710  //; pool of all param sets
3711  static CINOSMutex m_GlobalParamSetsMutex;
3712  //; global param set mutex
3713  static TINOSNameBalancedBinaryTree<CINOSBaseAxisParamSet>* m_pGlobalParamSets;
3714  //; pool of all param sets
3715  #ifdef INOS_MOVE_CACHE_SUPPORT
3716  CINOSMoveCache* m_pMoveCache;
3717  //; pointer to move cache
3718  #endif
3719 
3720  // actual commanded values
3721 
3723  SINOSRampDataEx* m_pActual;
3725  SINOSRampDataEx* m_pActRamp;
3727  SINOSRampDataEx* m_pActControl;
3729  SINOSRampDataEx* m_pRealVrt;
3730 
3731  // previous three commanded values
3732  SINOSRampData m_sPreviousVrt[3];
3733 
3734  // test values
3735 
3736  real64 m_rPos1;
3737  //; toggle position 1
3738  real64 m_rPos1Max;
3739  //; max. toggle position 1
3740  real64 m_rPos2;
3741  //; toggle position 2
3742  real64 m_rPos2Max;
3743  //; max. toggle position 2
3744  uint32 m_uDelay;
3745  //; delay in ms between toggles
3746  uint32 m_uDelayMax;
3747  //; max. delay in ms between toggles
3748  uint32 m_uDelayAct;
3749  //; act. delay in ms between toggles
3750  int32 m_iTicks;
3751  //; system ticks to handle delay
3752  uint32 m_uToggleCnt;
3753  //; toggle counter
3754 
3755  // miscelanselous
3756  real64 m_rFeedPerTurn;
3757  //; feed per turn (used in method NormPosition)
3758  real64 m_rFeedPerTurn_1;
3759  //; 1 / feed per turn (used in method NormPosition)
3760  real64 m_rInertia;
3761  //; inertia (used in torque limitation)
3762 
3763  inosName32 m_cSelectedParamName;
3764  //; last selected param name
3765 
3766  // emergency values
3767 
3768  uint32 m_uEmergencyType;
3769  //; type of emergency stop (0-Stop, 1-Stop/InActivate, 2-InActivate, 3-none
3770  //; 4-Position, 5-Position/InActivate)
3771  uint32 m_uEmergencyDelay;
3772  //; Delay [ms] after Stop till InActivate (Type = 1)
3773  real64 m_rEmergencyPosition;
3774  //; emergency position
3775  uint16 m_uIntEmergencyType;
3776  //; type of emergency stop (0-Stop, 1-Stop/InActivate, 2-InActivate)
3777  uint16 m_uIntEmergencyDelay;
3778  //; Delay [ms] after Stop till InActivate (Type = 1)
3779  SINOSRampParam* m_pEmergency;
3780  //; pointer to emergency speed set (if available)
3781 
3782  // cursoring
3783  uint32 m_uCurWaitTime;
3784  //; wait afet initial move
3785  real64 m_rCurPosition;
3786  //; cursoring direction
3787  SINOSRampParam* m_pCurParam;
3788  //; cursoring params
3789 
3790  // syncing
3791  uint8 m_uSyncMode;
3792  //; requested sync mode
3793  // sync methods available
3794  bool m_bSyncAvailable = true;
3795 
3796  // norming
3797  uint8 m_uNormMode;
3798  //; requested norm mode
3799  uint8 m_uNormMoveDir;
3800  //; requested norm move direction
3801  real64 m_rNormPos;
3802  //; requested norm position
3803 
3804  // multicore
3805 
3807  uint8 m_uCoreId = DF_INOS_CORE_DEFAULT;
3808 
3809  // tracking
3810  uint16 m_uTrackValType;
3811  //; tracking value type
3812  uint16 m_uTrackDir;
3813  //; tracking direction (0-pos and neg, 1-pos, 2-neg)
3814  void* m_pTrackVal;
3815  //; pointer to track value
3816  real64 m_rTrackCyc;
3817  //; track cycletime [sec]
3818  real64 m_rTrackFct;
3819  //; tracking factor
3820  real64 m_rTrackPos;
3821  //; tracking position
3822  real64 m_rTrackVel;
3823  //; tracking velocity
3824  real64 m_rTrackCmd;
3825  //; tracking commanded value
3826  real64 m_rTrackSum;
3827  //; tracking sum
3828  uint16 m_uTrackLen;
3829  //; tracking buffer length
3830  uint16 m_uTrackInd;
3831  //; tracking buffer index
3832  int32 m_iTrackLst;
3833  //; last track value
3834  int32 m_iTrackOld;
3835  //; old track value
3836  real64* m_pTrackBuf;
3837  //; pointer to tracking buffer
3838  tpGetter m_pTrackGet;
3839  //; pointer to tracking value getter method
3840  real64 m_rTrackVmax;
3841  real64 m_rTrackAmax;
3842  real64 m_rTrackBmax;
3843 
3844  // positioning
3845 
3846  uint32 m_uPosType;
3847  //; positioning type
3848  uint32 m_uPosTime;
3849  //; positioning time [ms]
3850  uint32 m_uPosTimeout;
3851  //; positioning timeout [ms]
3852  int32 m_iPosTicks;
3853  //; positioning ticks
3854  int32 m_iPosTimeout;
3855  //; positioning timeout ticks
3856  real64 m_rPosTolerance;
3857  //; positioning tolerance
3858 
3859  // save moves
3860 
3861  // exit time
3862  real64 m_rExitTime;
3863  // partner also running
3864  bool m_bPartnerMoving;
3865 
3866  // bus timing
3867 
3869  uint32 m_uBusTicksPerAxisTick;
3870 
3872  uint16 m_uCycleId;
3873 
3874  #ifdef INOS_USE_CUSTOMER_IMAGE_DATA
3875 
3880  void* m_pCustomerSpecificData;
3881  #endif
3882 
3883  // safety
3884 
3885  #ifdef INOS_SAFETY_SUPPORT
3886  tUid m_uSafetyUid;
3889  uint8 m_uSafetyLevel;
3891  uint8 m_uSafetyType;
3893  ESafetyFunction m_eSafetyFunction;
3895  real64 m_rSafetyLimit;
3897  uint32 m_uSafetyDelay;
3899  int32 m_iSafetySupervisionStart;
3901  real64 m_rSafetySupervisionLimit;
3903  SINOSBaseAxisHook* m_pSOSHooks;
3904 
3905  // also called from CINOSMcTargetSafety at reload of ch.indel.safety.config.img
3906  friend class CINOSMcTargetSafety;
3908  void iSetupSafety();
3910  virtual bool iSetupSafetyRegistration();
3911  #endif
3912 
3913  // axis extensions
3914 
3915  #if defined(INOS_AXIS_EXTENSION_SUPPORT)
3916  TINOSDoubleLinkedList<IINOSBaseAxisExtension>* m_pExtensions = 0;
3918  #endif
3919 
3920  // command parameters
3921  protected:
3922  uint32 m_ueActivateCheckPos;
3923  //; param : CheckPos
3924  uint32 m_ueActivateSimulatePos;
3925  //; param : SimulatePos
3926  uint32 m_ueActivateSimulateOut;
3927  //; param : SimulateOut
3928  uint32 m_ueActivateSimulateAct;
3929  //; param : SimulateAct
3930  real64 m_rePosition;
3931  //; param : Position
3932  real64 m_rePositionVel{};
3933  //; param : PositionVel
3934  real64 m_reVelocity{};
3935  //; param : Velocity
3936  real64 m_reSyncPosition;
3937  //; param : SyncPosition
3938  inosName32 m_ceParam;
3939  //; param : Param
3940  char m_ceVariable[64];
3941  //; param : Variable
3942  real64 m_reFactor;
3943  //; param : Factor
3944  real64 m_reValue;
3945  //; param : Value
3946  uint32 m_ueFilter;
3947  //; param : Filter
3948  uint32 m_ueTrackDir;
3949  //; param : Track direction
3950  uint32 m_ueDirection;
3951  //; param : Direction
3952  uint32 m_ueWait;
3953  //; param : Wait
3954  real64 m_reStep;
3955  //; param : Step
3956  real64 m_reReturn;
3957  //; param : return
3958  real64 m_reDelta;
3959  //; param : delta
3960  real64 m_reStart;
3961  //; param : start
3962  real64 m_reEnd;
3963  //; param : end
3964  uint32 m_ueReturn;
3965  //; param : return
3966  uint32 m_ueTicks;
3967  //; param : ticks
3968  real64 m_reTime;
3969  //; param : time
3970  real64 m_reSlowMotion;
3971  //; param SLowMotion
3972 
3973  #ifdef INOS_MOVEPATH_SUPPORT
3974  class CINCOMovePathActuals* m_pMovePathActuals;
3975  #endif
3976 
3977  // static private members
3978  private:
3979  static uint32 m_uCount;
3980  //; number of axis in pool
3981  static uint8 m_uCountCoreId;
3982  //; current core id
3983  static CINOSBaseAxis* m_pFirst;
3984  //; pointer to first axis
3985  CINOSBaseAxis* m_pNext;
3986  //; pointer to next axis in the chain of all axis
3987  static CINOSBaseAxis* m_pAxis[DF_INOS_MAX_AXIS];
3988  //; array of axis pointers
3989  static char m_cStateCombo[494];
3990  //; axis state INCO item text. Use 494 (=defMaxDataLength). I fear
3991  //; to include inco_com.h here, that's why a plain number is used)
3992 
3993  // allow dynamic object handling (new/delete)
3994  DECLARE_DYNAMIC(CINOSBaseAxis);
3995 };
3996 
3997 //------------------------------------------------------------------------------
3998 // class registration
3999 //------------------------------------------------------------------------------
4000 
4002 typedef CINOSBaseAxis *(*TCreateAxis)(const char* apAxisName);
4003 class CINOSRegisterBaseAxis
4004 {
4005  // after this function you can register new ramps
4006  friend void _INI_0000_CINOSRegisterBaseAxis();
4007 
4008  //--- internals --------------------------------------------------------
4009  // private members
4010 private:
4011  // pointer to the first registered axis
4012  static CINOSRegisterBaseAxis* m_pFirst;
4013  // pointer to the next axis
4014  CINOSRegisterBaseAxis* m_pNext;
4015  // create funtion for axis
4016  TCreateAxis m_pCreate;
4017  // axis type name
4018  const char* m_pAxisType;
4019  // database table name
4020  const char* m_pDatabaseTable;
4021 
4022  //--- user interface ---------------------------------------------------
4023 
4024 public:
4025  // register a new axis type
4026  CINOSRegisterBaseAxis(TCreateAxis apFunction, const char* apAxisType,
4027  const char* apDatabaseTable);
4028 
4029  // create and return and new axis instance
4030  static CINOSBaseAxis* GetAxis(const char* apAxisName, const char* apAxisType);
4031  // create all registered axis
4032  static void CreateAll();
4033 };
4035 
4036 //
4037 //------------------------------------------------------------------------------
4038 //--- helper macros ------------------------------------------------------------
4039 //------------------------------------------------------------------------------
4040 //
4041 #if defined(INOS_MULTICORE)
4042 #define INOS_AXIS_CORE_MISMATCH_IS_ERROR(ret) \
4043 if ((m_uCoreId != DF_INOS_CORE_DEFAULT) && (::GetCoreId() != m_uCoreId)) { \
4044  if (!(GetFlag() & DF_INOS_AXIS_FLAG_IGNORE_CORE)) { \
4045  iCoreMismatchError(); \
4046  return ret; \
4047  } \
4048 }
4049 #else
4050 #define INOS_AXIS_CORE_MISMATCH_IS_ERROR(ret)
4051 #endif
4052 
4053 
4054 //
4055 //------------------------------------------------------------------------------
4056 // safety macros
4057 //------------------------------------------------------------------------------
4058 //
4059 #ifdef INOS_SAFETY_SUPPORT
4060 #define SAFETY_CHECK_SOS() \
4061  if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) { \
4062  if (m_eSafetyFunction == eSafetyFunctionSOS) { \
4063  real64 rSlowMotion; GetActSlowMotion(rSlowMotion); \
4064  if (rSlowMotion != REAL64(0.0)) { \
4065  m_uError |= ER_INOS_AXIS_REJECTED_SOS; \
4066  INOS_ERROR("AXIS[%s]: Command rejected, axis in SOS (safe operating stop)", GetName());\
4067  return m_uError; \
4068  } \
4069  } \
4070  }
4071 //
4072 #define SAFETY_CHECK_SOS_SYNC(apSync) \
4073  if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) { \
4074  if (m_eSafetyFunction == eSafetyFunctionSOS) { \
4075  real64 rSlowMotion; GetActSlowMotion(rSlowMotion); \
4076  if (rSlowMotion != REAL64(0.0)) { \
4077  m_uError |= ER_INOS_AXIS_REJECTED_SOS; \
4078  INOS_ERROR("AXIS[%s]: Command rejected, axis in SOS (safe operating stop)", GetName());\
4079  Signal(apSync); \
4080  return m_uError; \
4081  } \
4082  } \
4083  }
4084 //
4085 #define SAFETY_IGNORE_IF_SOS() \
4086  if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) { \
4087  if (m_eSafetyFunction == eSafetyFunctionSOS) { \
4088  return m_uError; \
4089  } \
4090  }
4091 #else
4092 #define SAFETY_CHECK_SOS()
4093 #define SAFETY_CHECK_SOS_SYNC(apSync)
4094 #define SAFETY_IGNORE_IF_SOS()
4095 #endif
4096 //
4097 //------------------------------------------------------------------------------
4098 // end of file
4099 //------------------------------------------------------------------------------
4100 
4101 #endif // INC_CINOSBASEAXIS_H
CINOSMutex
Definition: cinosmutex.h:35
CINOSBus
Definition: cinosbus.h:562
CINOSBaseAxis::Break
virtual uint32 Break(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Pause a running move with the currently selected speed set. The move is still pending and can be cont...
DF_INOS_AXIS_NORM_AFTER
#define DF_INOS_AXIS_NORM_AFTER
Definition: cinosbaseaxis.h:171
CINOSBaseAxis::SetTrackFactor
virtual uint32 SetTrackFactor(real64 arFactor)
Allows to live change the tracking factor of an active 'Track'.
CINOSBaseAxis::GetDecelerationTicks
virtual int32 GetDecelerationTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs for the deceleration part.
CINOSBaseRamp::GetTrqLimitAcceleration
SINOSBaseRampTrqLimit * GetTrqLimitAcceleration()
get torque limit acceleration
Definition: cinosbaseramp.h:1343
CINOSBaseAxis::GetExitTicks
virtual int32 GetExitTicks()
Calc bus ticks needed till exit in a safe move.
CINOSBaseAxis::SegMove
virtual uint32 SegMove(real64 arPosition)
Add a move to arPosition. Velocity and acceleration in arPosition have to be 0.0.
SINOSTimeCharacteristics
time characteristics of a move
Definition: cinosbaseramp.h:627
CINOSMutex::GetOwner
ICACHE class CINOSTask * GetOwner()
Return id of mutex owner.
Definition: cinosmutex.h:118
CINOSBaseAxis::Update
virtual uint32 Update(CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
Update a running Move to actual commanded values (acc,dec,vel,jerk) Signal apSync if constant velocit...
CINOSBaseAxis::GetAxis
static CINOSBaseAxis * GetAxis(uint32 auNumber)
Get pointer to axis with a given number.
Definition: cinosbaseaxis.h:714
SINOSBaseAxis::m_uTestDelay
uint32 m_uTestDelay
For testing purposes, an axis provides a test folder in the INCO tree where one can toggle the axis b...
Definition: cinosbaseaxis.h:462
CINOSBaseAxis::SegPos
virtual uint32 SegPos(real64 arTime)
stay at actual position for arTime [sec].
CINOSBaseAxis::Cursor
virtual uint32 Cursor(bool abPositive=true)
Moves one 'inc' in the requested direction, waits 500ms and starts an endless move to the defined sof...
SINOSBaseAxis::m_rNormPos
real64 m_rNormPos
Defines the default norming position, e.g. 360.0 for a turning axis.
Definition: cinosbaseaxis.h:548
CINOSBaseAxis::GetStartTicks
virtual uint64 GetStartTicks(real64 arDelta)
Get absolut bus ticks the actual move reaches the start position + arDelta.
CINOSBaseAxis::GetAxis
static CINOSBaseAxis * GetAxis(const char *apAxisName)
Get pointer to axis with name apAxisName.
CINOSBaseAxis::GetConstTicks
virtual int32 GetConstTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs for the constant part.
CINOSBaseAxis::MoveDep
virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with actual commanded jerk, acc/deceleration and velocity. Ensure befor arPosition...
SINOSMovePathActual
Definition: cinosmovepathtrajectory.h:49
SINOSBaseAxis::m_cName
inosName64 m_cName
Axis name.
Definition: cinosbaseaxis.h:397
SINOSBaseAxis::m_rTestPos1
real64 m_rTestPos1
Test mode position 1, see also m_rTestPos2 and m_uTestDelay.
Definition: cinosbaseaxis.h:466
SINOSBaseAxis::m_uOptions
uint32 m_uOptions
Axis options, see DF_INOS_BASE_AXIS_OPT_EARLY_DONE, DF_INOS_BASE_AXIS_OPT_AUTO_ACCEPT,...
Definition: cinosbaseaxis.h:432
CINOSBaseAxis
Provides axis functionality.
Definition: cinosbaseaxis.h:679
SINOSBaseAxis::m_uPosTimeout
uint32 m_uPosTimeout
Default positioning timeout [ms] for types DF_INOS_AXIS_PST_WINDOW and DF_INOS_AXIS_PST_WINDOW_OPT.
Definition: cinosbaseaxis.h:510
INOS_OR
#define INOS_OR(variable, mask)
Definition: inosmacro.h:201
CINOSBaseAxis::StopLiveDelta
virtual uint32 StopLiveDelta(real64 arDelta, real64 arSlowMotion, SINOSRampParam *apParam=nullptr)
Stop a running move with the given speed set and required slowmotion factor. The stop is calculated l...
CINOSBaseAxis::GetActVrt
SINOSRampData * GetActVrt()
deprecated
Definition: cinosbaseaxis.h:3289
CINOSBaseAxis::InitializeLimitChecker
void InitializeLimitChecker()
Initializes the limit checker if requested.
CINOSBaseRamp::GetTrqLimitDeceleration
SINOSBaseRampTrqLimit * GetTrqLimitDeceleration()
get torque limit deceleration
Definition: cinosbaseramp.h:1349
CINOSBaseAxis::StopLive
virtual uint32 StopLive()
Stop a running move with the currently selected speed set. The stop is calculated live and therefore ...
SINOSBaseAxis::m_cShort
uint16 m_cShort
Gives the user the possibility to define a short one character based axis alias. This option is depre...
Definition: cinosbaseaxis.h:525
CINOSBaseAxis::GetTimeCharacteristics
virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition)
Calculate time characteristics of a move.
SINOSRampData
ramp data
Definition: cinosbaseramp.h:601
DF_INOS_AXIS_NORM_MOVE_DIR_NO
#define DF_INOS_AXIS_NORM_MOVE_DIR_NO
Definition: cinosbaseaxis.h:188
SINOSBaseAxis::m_uNormMoveDir
uint8 m_uNormMoveDir
Used to define the default axis norm moving direction, e.g. move always in positive direction,...
Definition: cinosbaseaxis.h:544
CINOSBaseAxis::EnableNorm
virtual void EnableNorm(uint8 auMode=0x00, uint8 auMoveDir=0x00, real64 arNormPos=REAL64(0.0))
CINOSBaseAxis::m_pActual
SINOSRampDataEx * m_pActual
actual commanded values (handed over to control)
Definition: cinosbaseaxis.h:3723
SINOSBaseAxis::m_cDescription
inosName64 m_cDescription
Axis description.
Definition: cinosbaseaxis.h:563
SINOSBaseAxis::m_uPosType
uint32 m_uPosType
Tells the system how an end of a move is defined. There are three different type available,...
Definition: cinosbaseaxis.h:500
DF_INOS_AXIS_NORM_ROUND
#define DF_INOS_AXIS_NORM_ROUND
Definition: cinosbaseaxis.h:182
SINOSBaseAxis::m_cEmergencyParam
inosName32 m_cEmergencyParam
Name of the speed set to be used for emergency stops.
Definition: cinosbaseaxis.h:559
INOS_INLINE
#define INOS_INLINE
Definition: inosdefine.h:60
SINOSBaseAxis::m_uPosTime
uint32 m_uPosTime
Default positioning time [ms] for types DF_INOS_AXIS_PST_WINDOW and DF_INOS_AXIS_PST_WINDOW_OPT.
Definition: cinosbaseaxis.h:505
CINOSBaseAxis::InActivate
virtual uint32 InActivate(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Inactivate axis.
SINOSBaseAxis::m_uCacheSize
uint32 m_uCacheSize
Used to define a cache size for the special safe move commands. Currently only used on a special cust...
Definition: cinosbaseaxis.h:520
cinosbaseramp.h
Short comment.
SINOSBaseAxis::m_rTrackFactor
real64 m_rTrackFactor
Defines the default tracking factor.
Definition: cinosbaseaxis.h:487
CINOSBaseAxis::GetMoveDist
virtual real64 GetMoveDist(real64 arTime)
Calc distance [unit] a Move progresses in arTime [sec].
CINOSBaseAxis::GetName
virtual const char * GetName()
CINOSBaseRamp
Definition: cinosbaseramp.h:751
DF_INOS_ASYNCHRONOUS
#define DF_INOS_ASYNCHRONOUS
Definition: inosmacro.h:337
CINOSBaseAxis::Activate
virtual uint32 Activate(bool abCheckPos=true, bool abSimulatePos=false, bool abSimulateOut=false, bool abSimulateAct=false, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Activate axis in a given mode, e.g Activate(true,true,true,true) enables the axis in a full simulated...
CINOSBaseAxis::m_pActRamp
SINOSRampDataEx * m_pActRamp
actual commanded values from ramp geni
Definition: cinosbaseaxis.h:3725
CINOSBaseAxis::Move
virtual uint32 Move(real64 arPosition, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with actual commanded jerk, acc/deceleration and velocity.
CINOSBaseAxis::SegBegin
virtual uint32 SegBegin(real64 arSlowMotion=REAL64(1.0), real64 arStartVelocity=REAL64(0.0))
Create a new segmentation move.
SINOSBaseAxis::m_cDefaultParam
inosName32 m_cDefaultParam
If this string is not empty and the axis ramps A,V,J are set to 0.0 (means undefined) then the speed ...
Definition: cinosbaseaxis.h:555
CINOSBaseAxis::GetAccelerationTime
virtual real64 GetAccelerationTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::GetActPosition
virtual void GetActPosition(real64 &arPosition, bool abRamp=true)
Gets the actual axis position.
CINOSBaseAxis::Stop
virtual uint32 Stop(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Stop a running move with the currently selected speed set.
SINOSBaseAxis
Descriptor structure used to configure a base axis. It is usually only used in conjunction with SINOS...
Definition: cinosbaseaxis.h:393
CINOSBaseAxis::Relax
virtual uint32 Relax(uint32 auTimeMs, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Relax a coupled slave axis for a given time.
CINOSBaseAxis::CINOSBaseAxis
CINOSBaseAxis(SINOSBaseAxis *apDesc)
Create an axis based on a descriptor (usually not used because this is done by the configuration syst...
SINOSRampDataEx
extended ramp data
Definition: cinosbaseramp.h:616
CINOSBaseAxis::m_uBusTicksPerAxisTick
uint32 m_uBusTicksPerAxisTick
number of bus ticks an axis tick takes
Definition: cinosbaseaxis.h:3869
CINOSBaseAxis::SegConst
virtual uint32 SegConst(real64 arPosition)
Add a move to arPosition with actual velocity.
CINOSBaseAxis::GetTrqLimitAcceleration
SINOSBaseRampTrqLimit * GetTrqLimitAcceleration()
get torque limit acceleration
Definition: cinosbaseaxis.h:3340
CINOSBaseAxis::SegRun
virtual uint32 SegRun(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Run actual segments.
CINOSBaseAxis::Connect
virtual uint32 Connect()
Connect axis to hardware.
Definition: cinosbaseaxis.h:741
SINOSBaseAxis::m_rTestPos1Max
real64 m_rTestPos1Max
Test mode position 1 maximum, see also m_rTestPos1.
Definition: cinosbaseaxis.h:470
CINOSBaseAxis::MoveApp
virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition with actual commanded jerk, acc/deceleration and velocity. Ensure after arPosition...
CINOSBus::AtomicGatherEnter
INOS_INLINE void AtomicGatherEnter(uint32 &ouToken)
Definition: cinosbus.h:950
CINOSBaseAxis::Track
virtual uint32 Track(const char *apVarName, real64 arFactor, uint32 auFilterLength, uint32 auDirection=0)
Track the variable with name apVarName.
CINOSBaseAxis::Disable
virtual uint32 Disable(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Disables an enabled axis. Only inactivated axis can be disabled. Use 'Enable' to reenable the axis.
CINOSBaseAxis::Continue
virtual uint32 Continue(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Continue a pause move.
CINOSBaseAxis::EmergencyStopLive
virtual uint32 EmergencyStopLive()
Stop a running move with the defined emergency deceleration/jerk. The stop is calculated live and the...
CINOSBaseAxis::Toggle
virtual uint32 Toggle(real64 arPosition1, real64 arPosition2)
Start an endless toggle between arPosition1 and arPosition2 with actual commanded a jerk,...
CINOSBaseAxis::Pull
virtual uint32 Pull(real64 arS, real64 arV, real64 arA, real64 arJ)
Add a path point to the actual pull list and start pull mode if not et done. If one is running an axi...
SINOSBaseAxis::m_uCoreId
uint8 m_uCoreId
Id of core the axis has to run on. In the configuration file do not define this value or set it to 0x...
Definition: cinosbaseaxis.h:415
INOS_AND
#define INOS_AND(variable, mask)
Definition: inosmacro.h:210
CINOSBaseAxis::GetMoveTime
virtual real64 GetMoveTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs until arPosition.
CINOSBaseAxis::SetActPosition
virtual uint32 SetActPosition(real64 arPosition)
Sets the actual axis position. This method doesn't change a current following error and it is therefo...
cinosbus.h
Short comment.
SINOSBaseAxis::m_uNormMode
uint8 m_uNormMode
Used to define the default axis norming mode, e.g. norm an turn axis to 0..360° see DF_INOS_AXIS_NORM...
Definition: cinosbaseaxis.h:534
CINOSBaseRampParamSet
Definition: cinosbaseramp.h:696
CINOSBaseAxis::ToggleSection
virtual uint32 ToggleSection(real64 arPos1Min, real64 arPos1Max, real64 arPos2Min, real64 arPos2Max, uint32 auDelayMin, uint32 auDelayMax)
Start an endless section toggle between arPosition1 and arPosition2 with actual commanded a jerk,...
CINOSBaseAxis::SegVelocity
virtual uint32 SegVelocity(real64 arVelocity, SINOSRampParam *apParam)
Directly change velocity to the new value.
tUid
uint32 tUid
Definition: inostype.h:190
CINOSBaseAxis::DisableNorm
virtual void DisableNorm()
SINOSBaseAxis::m_uTrackFilterLength
uint32 m_uTrackFilterLength
Defines the default tracking filter length.
Definition: cinosbaseaxis.h:491
SINOSBaseAxis::m_uEmergencyType
uint8 m_uEmergencyType
Defines the default behaviour in case of an emergency stop of the axis. An emergency stop is either i...
Definition: cinosbaseaxis.h:451
CINOSBaseAxis::m_uCycleId
uint16 m_uCycleId
cycle id
Definition: cinosbaseaxis.h:3872
CINOSBaseAxis::Sync
virtual uint32 Sync(real64 arPosition, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Search reference mark till arPosition and set actual position to 0.0 at mark.
SINOSBaseAxis::m_uNumber
uint16 m_uNumber
Optional axis number. This value is only used on specific Indel targets like e.g. a GIN-AX4x4 to defi...
Definition: cinosbaseaxis.h:410
SINOSBaseAxis::m_rPosTolerance
real64 m_rPosTolerance
Default positioning tolerance [unit] for types DF_INOS_AXIS_PST_WINDOW and DF_INOS_AXIS_PST_WINDOW_OP...
Definition: cinosbaseaxis.h:515
CINOSBaseAxis::GetMoveTicks
virtual int32 GetMoveTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs until arPosition.
CINOSBaseAxis::SetNormMoveDir
virtual void SetNormMoveDir(uint8 auNormMoveDir)
Definition: cinosbaseaxis.h:3235
CINOSBaseAxis::GetAccelerationTicks
virtual int32 GetAccelerationTicks(real64 arPosition)
Calc bus ticks a Move(adPosition) needs for the acceleration part.
CINOSBaseAxis::GetMoveAppTime
virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, real64 arVelocity)
Calc time [sec] an according MoveApp needs.
CINOSBaseAxis::GetDecelerationTime
virtual real64 GetDecelerationTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs for the deceleration part.
CINOSBaseAxis::Endless
virtual uint32 Endless(bool abPositive=true)
Start and endless move in the requested direction with actual commanded acc/dec and velocity.
CINOSBaseAxis::GetRealPosition
virtual void GetRealPosition(real64 &arPosition, bool abMapped=true)
Gets the real axis position.
SINOSBaseAxis::m_uEmergencyDelay
uint16 m_uEmergencyDelay
The required default delay [ms] if working with emergency type DF_INOS_AXIS_EMGT_STOP_INACTIVATE.
Definition: cinosbaseaxis.h:456
SINOSBaseAxis::m_rEmergencyPosition
real64 m_rEmergencyPosition
Emergency stop position (used in emergency types DF_INOS_AXIS_EMGT_STOP_POSITION and DF_INOS_AXIS_EMG...
Definition: cinosbaseaxis.h:483
CINOSPhysicalAxis
Provides physical aka real axis functionality.
Definition: cinosphysicalaxis.h:286
DF_INOS_SYNCHRONOUS
#define DF_INOS_SYNCHRONOUS
Definition: inosmacro.h:332
CINOSBaseAxis::NormPosition
double NormPosition(real64 arPosition) const
Returned the 'normed' value of arPosition.
Definition: cinosbaseaxis.h:2779
CINOSBaseAxis::GetToggleCnt
virtual uint32 GetToggleCnt()
get current toggle counter
Definition: cinosbaseaxis.h:3327
CINOSBaseAxis::m_pActControl
SINOSRampDataEx * m_pActControl
actual commanded values (valid if mapping active or after a SetActual)
Definition: cinosbaseaxis.h:3727
CINOSBaseAxis::WaitTicks
virtual uint32 WaitTicks(uint32 auTicks=1)
Wait for the given axis control cycle ticks. This method can be useful if it is necessary to synchron...
CINOSBaseAxis::GetConstTime
virtual real64 GetConstTime(real64 arPosition)
Calc time [sec] a Move(adPosition) needs for the constant part.
CINOSBaseAxis::m_pRealVrt
SINOSRampDataEx * m_pRealVrt
actual real virtual values
Definition: cinosbaseaxis.h:3729
SINOSBaseRampTrqLimit
torque limitation
Definition: cinosbaseramp.h:660
SINOSBaseAxis::m_uSafetyType
uint8 m_uSafetyType
Defines the behaviour in case of an SOS request DF_INOS_AXIS_SAFETY_EMGSTOP, DF_INOS_AXIS_SAFETY_AUTO...
Definition: cinosbaseaxis.h:439
CINOSBaseAxis::GetTrqLimitDeceleration
SINOSBaseRampTrqLimit * GetTrqLimitDeceleration()
get torque limit deceleration
Definition: cinosbaseaxis.h:3343
CINOSBaseAxis::GetActPhy
SINOSRampData * GetActPhy()
deprecated
Definition: cinosbaseaxis.h:3292
CINOSBaseAxis::GetActual
SINOSRampData * GetActual(EActualType aeType=eActOutput, bool abCopy=true)
get pointer to actual control values
Definition: cinosbaseaxis.h:3262
CINOSBaseAxis::EmergencyStop
virtual uint32 EmergencyStop(CINOSSync *apSync)
Stop a running move with the defined emergency deceleration/jerk.
CINOSBaseAxis::m_uCoreId
uint8 m_uCoreId
id of core the axis is handled in
Definition: cinosbaseaxis.h:3807
SINOSBaseAxis::m_rTestPos2Max
real64 m_rTestPos2Max
Test mode position 2 maximum, see also m_rTestPos2.
Definition: cinosbaseaxis.h:478
CINOSBaseAxis::SetRealPosition
virtual uint32 SetRealPosition(real64 arPosition)
Sets the real axis position. This method ignores a current following error and should therefore NOT b...
SINOSBaseAxis::m_cRampType
inosName32 m_cRampType
Trajectory generator name. Valid types are INOSJerkRamp, INOSJerkTrqRamp, INOSTrapezeRamp or a custom...
Definition: cinosbaseaxis.h:403
SINOSBaseAxis::m_uReserved
uint8 m_uReserved
Reserved for future use.
Definition: cinosbaseaxis.h:419
CINOSSync
Definition: inos_syn.h:66
DECLARE_DYNAMIC
#define DECLARE_DYNAMIC(aClass)
Definition: cinospartitionmemory.h:328
CINOSBaseAxis::GetBusTicksPerAxisTick
virtual uint32 GetBusTicksPerAxisTick()
Get number of bus ticks an axis tick takes.
CINOSBaseAxis::WaitInPosition
virtual uint32 WaitInPosition()
Wait for any move to finish.
CINOSBaseAxis::GetMoveDepTime
virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, real64 arVelocity)
Calc time [sec] an according MoveDep needs.
SINOSRampParam
ramp parameters
Definition: cinosbaseramp.h:502
CINOSBaseAxis::GetRealVrt
SINOSRampData * GetRealVrt()
get pointer to real values
Definition: cinosbaseaxis.h:3286
CINOSBaseAxis::GetTargetTicks
virtual uint64 GetTargetTicks()
Get absolut bus ticks the actual move reaches the target position.
CINOSBaseAxis::SetNormMode
virtual void SetNormMode(uint8 auNormMode)
Definition: cinosbaseaxis.h:3243
SINOSBaseAxis::m_rTestPos2
real64 m_rTestPos2
Test mode position 2, see also m_rTestPos1 and m_uTestDelay.
Definition: cinosbaseaxis.h:474
CINOSBaseAxis::Enable
virtual uint32 Enable(CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Enables a previously disabled axis. Only enabled axis can be activated.
CINOSBaseAxis::EnableRamp
void EnableRamp()
Enable a recently disabled trajectory generator.
Definition: cinosbaseaxis.h:2450
CINOSBaseAxis::SegTime
virtual real64 SegTime()
Returns time the actual segment move takes.
CINOSBaseAxis::~CINOSBaseAxis
virtual ~CINOSBaseAxis()
Destroy the axis (usually not used)
CINOSBaseAxis::DisableRamp
void DisableRamp()
Disable the axis trajectory generator. Can be used to fill up a pull list without staring immediately...
Definition: cinosbaseaxis.h:2460
DF_INOS_CORE_DEFAULT
#define DF_INOS_CORE_DEFAULT
Definition: inosdefine.h:175
CINOSBaseAxis::GetNormMoveDir
virtual uint8 GetNormMoveDir()
Definition: cinosbaseaxis.h:3231
CINOSBaseAxis::GetNormMode
virtual uint8 GetNormMode()
Definition: cinosbaseaxis.h:3239
CINOSBaseAxis::SegPosSetTime
virtual uint32 SegPosSetTime(real64 arTime)
Sets the time of the last added segpos segment [sec]. Can be used to adjust a previous added pos segm...
CINOSBaseAxis::GetCoreId
uint8 GetCoreId()
get core id the axis is running on
Definition: cinosbaseaxis.h:3349
CINOSBaseAxis::MoveTime
virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5=true, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
Move to arPosition within the given time arTime. Actual commanded jerk, acc/deceleration and velocity...
CINOSBaseAxis::SetToggleCnt
virtual void SetToggleCnt(uint32 auSetVal)
set toggle counter to given value
Definition: cinosbaseaxis.h:3330